refactor: 上报归属收敛——节点为唯一记录者，废除前端转发双算协议

- frontend-ssr(Nuxt TS 中间件)：移除转发路径上的 /report 数据上报与 X-Boce-Reporter 归属标记头及 nuxt.config 上报配置，本转发入口不再计数(转发请求也不再携带防双算标记)
- src/report.go：归属规则改为"节点是唯一记录者"，统计与拨测明细均由本节点上报，中间件不在转发路径计数故不存在双算；HTTP(/v1) 与 WS 下发两条来源都上报；明细类型扩充为 tcping/speed/detail/ssl/dns(dnssec 只进统计不进明细)；废除按 requestId/X-Boce-Reporter 判归属，改用 X-Scheduler-Probe 头(HTTP)与 Scheduler 标记(WS)区分收集中心主动调度拨测(收集中心侧本地落库 sched/biz，本节点跳过避免双算)
- src/ws.go：wsHandleProbe 识别 Scheduler=true 仅回 probe_result 不上报
- 依赖整理：AdguardTeam/golibs 转直接依赖，go.sum tidy

.github/workflows/build_and_release.yml

@@ -17,7 +17,7 @@ jobs:
             - name: Setup Go
               uses: actions/setup-go@v4
               with:
-                go-version: '1.26.2' # 选择适合的 Go 版本
+                go-version: '1.26.6' # 与 src/go.mod 声明保持一致，避免依赖 GOTOOLCHAIN 隐式下载
             - name: Set version metadata
               run: |
                 echo "VERSION=${GITHUB_REF_NAME}" >> $GITHUB_ENV  
@@ -25,31 +25,35 @@ jobs:
                 echo "BUILD_TIME=$(date -u +%Y-%m-%dT%H:%M:%SZ)" >> $GITHUB_ENV
 
             - name: Build for Linux
+              working-directory: src
               run: |
                 LDFLAGS="-X main.VERSION=${VERSION} -X main.COMMIT=${COMMIT} -X main.BUILD_TIME=${BUILD_TIME}"
-                CGO_ENABLED=0 GOOS=linux GOARCH=386 go build -ldflags "$LDFLAGS" -o lemonipw-linux-386
-                CGO_ENABLED=0 GOOS=linux GOARCH=amd64 go build -ldflags "$LDFLAGS" -o lemonipw-linux-amd64
-                CGO_ENABLED=0 GOOS=linux GOARCH=arm64 go build -ldflags "$LDFLAGS" -o lemonipw-linux-arm64
-                CGO_ENABLED=0 GOOS=linux GOARCH=arm GOARM=7 go build -ldflags "$LDFLAGS" -o lemonipw-linux-armv7
-                CGO_ENABLED=0 GOOS=linux GOARCH=arm GOARM=6 go build -ldflags "$LDFLAGS" -o lemonipw-linux-armv6
-                CGO_ENABLED=0 GOOS=linux GOARCH=loong64 go build -ldflags "$LDFLAGS" -o lemonipw-linux-loong64
+                CGO_ENABLED=0 GOOS=linux GOARCH=386 go build -ldflags "$LDFLAGS" -o ../lemonipw-linux-386
+                CGO_ENABLED=0 GOOS=linux GOARCH=amd64 go build -ldflags "$LDFLAGS" -o ../lemonipw-linux-amd64
+                CGO_ENABLED=0 GOOS=linux GOARCH=arm64 go build -ldflags "$LDFLAGS" -o ../lemonipw-linux-arm64
+                CGO_ENABLED=0 GOOS=linux GOARCH=arm GOARM=7 go build -ldflags "$LDFLAGS" -o ../lemonipw-linux-armv7
+                CGO_ENABLED=0 GOOS=linux GOARCH=arm GOARM=6 go build -ldflags "$LDFLAGS" -o ../lemonipw-linux-armv6
+                CGO_ENABLED=0 GOOS=linux GOARCH=loong64 go build -ldflags "$LDFLAGS" -o ../lemonipw-linux-loong64
             - name: Build for Windows
+              working-directory: src
               run: |
                 LDFLAGS="-X main.VERSION=${VERSION} -X main.COMMIT=${COMMIT} -X main.BUILD_TIME=${BUILD_TIME}"
-                CGO_ENABLED=0 GOOS=windows GOARCH=386 go build -ldflags "$LDFLAGS" -o lemonipw-windows-386.exe
-                CGO_ENABLED=0 GOOS=windows GOARCH=amd64 go build -ldflags "$LDFLAGS" -o lemonipw-windows-amd64.exe
-                CGO_ENABLED=0 GOOS=windows GOARCH=arm64 go build -ldflags "$LDFLAGS" -o lemonipw-windows-arm64.exe
+                CGO_ENABLED=0 GOOS=windows GOARCH=386 go build -ldflags "$LDFLAGS" -o ../lemonipw-windows-386.exe
+                CGO_ENABLED=0 GOOS=windows GOARCH=amd64 go build -ldflags "$LDFLAGS" -o ../lemonipw-windows-amd64.exe
+                CGO_ENABLED=0 GOOS=windows GOARCH=arm64 go build -ldflags "$LDFLAGS" -o ../lemonipw-windows-arm64.exe
             - name: Build for macOS
+              working-directory: src
               run: |
                 LDFLAGS="-X main.VERSION=${VERSION} -X main.COMMIT=${COMMIT} -X main.BUILD_TIME=${BUILD_TIME}"
-                CGO_ENABLED=0 GOOS=darwin GOARCH=amd64 go build -ldflags "$LDFLAGS" -o lemonipw-darwin-amd64
-                CGO_ENABLED=0 GOOS=darwin GOARCH=arm64 go build -ldflags "$LDFLAGS" -o lemonipw-darwin-arm64
+                CGO_ENABLED=0 GOOS=darwin GOARCH=amd64 go build -ldflags "$LDFLAGS" -o ../lemonipw-darwin-amd64
+                CGO_ENABLED=0 GOOS=darwin GOARCH=arm64 go build -ldflags "$LDFLAGS" -o ../lemonipw-darwin-arm64
             - name: Build for FreeBSD
+              working-directory: src
               run: |
                 LDFLAGS="-X main.VERSION=${VERSION} -X main.COMMIT=${COMMIT} -X main.BUILD_TIME=${BUILD_TIME}"
-                CGO_ENABLED=0 GOOS=freebsd GOARCH=386 go build -ldflags "$LDFLAGS" -o lemonipw-freebsd-386
-                CGO_ENABLED=0 GOOS=freebsd GOARCH=amd64 go build -ldflags "$LDFLAGS" -o lemonipw-freebsd-amd64
-                CGO_ENABLED=0 GOOS=freebsd GOARCH=arm64 go build -ldflags "$LDFLAGS" -o lemonipw-freebsd-arm64
+                CGO_ENABLED=0 GOOS=freebsd GOARCH=386 go build -ldflags "$LDFLAGS" -o ../lemonipw-freebsd-386
+                CGO_ENABLED=0 GOOS=freebsd GOARCH=amd64 go build -ldflags "$LDFLAGS" -o ../lemonipw-freebsd-amd64
+                CGO_ENABLED=0 GOOS=freebsd GOARCH=arm64 go build -ldflags "$LDFLAGS" -o ../lemonipw-freebsd-arm64
             - name: Build middleware-go for Linux
               working-directory: middleware-go
               run: |
@@ -82,8 +86,8 @@ jobs:
                 CGO_ENABLED=0 GOOS=freebsd GOARCH=arm64 go build -ldflags "$LDFLAGS" -o ../middleware-go-freebsd-arm64
             - name: Prepare config files for release
               run: |
-                # 后端：发布真实 setting.json（重命名为 setting.json.example）；中间件：只发布 setting.json.example
-                cp setting.json setting.json.example
+                # 后端：发布 src/ 下的 setting.json.example；中间件：只发布 setting.json.example
+                cp src/setting.json.example setting.json.example
                 cp middleware-go/setting.json.example middleware.setting.json.example
             - name: Release
               uses: softprops/action-gh-release@v3

.github/workflows/docker.yml

@@ -0,0 +1,189 @@
+name: Docker Multi-Arch
+
+# 打 v* 标签发版时构建多架构镜像并推送到 GHCR + Docker Hub。
+# ARM 用 GitHub 原生 arm64 实例（ubuntu-24.04-arm，公开仓库免费）交叉编译，全程无 QEMU：
+#   - ubuntu-latest        → linux/amd64（原生）
+#   - ubuntu-24.04-arm     → linux/arm64（原生）、linux/arm/v7（Go 交叉编译，GOARM 由 Dockerfile 处理）
+# 各平台按 digest 推到 GHCR，最后由 merge job 用 buildx imagetools 合并成多架构
+# manifest list，同时打上 GHCR 与 Docker Hub 的标签。
+#
+# Docker Hub 推送为可选：需要仓库 Secrets 配置 DOCKERHUB_USERNAME / DOCKERHUB_TOKEN，
+# 未配置时只推 GHCR，不影响流程。
+on:
+  push:
+    tags:
+      - 'v*'
+  workflow_dispatch:
+
+permissions:
+  contents: read
+  packages: write
+
+jobs:
+  build:
+    runs-on: ${{ matrix.runner }}
+    strategy:
+      fail-fast: false
+      matrix:
+        # 纯 include 模式：每条自带全部字段，独立成一个任务。
+        # 注意不能把 image 写成顶层数组再用 include 拆——GitHub 会把能匹配
+        # 现有组合的 include 条目合并进组合本身，导致任务被折叠（见 v3.3.0 事故）
+        include:
+          - image: lemon-ipw
+            context: src
+            runner: ubuntu-latest
+            platforms: linux/amd64
+            platform_id: amd64
+          - image: lemon-ipw
+            context: src
+            runner: ubuntu-24.04-arm
+            platforms: linux/arm64
+            platform_id: arm64
+          - image: lemon-ipw
+            context: src
+            runner: ubuntu-24.04-arm
+            platforms: linux/arm/v7
+            platform_id: armv7
+          - image: lemon-ipw-middleware
+            context: middleware-go
+            runner: ubuntu-latest
+            platforms: linux/amd64
+            platform_id: amd64
+          - image: lemon-ipw-middleware
+            context: middleware-go
+            runner: ubuntu-24.04-arm
+            platforms: linux/arm64
+            platform_id: arm64
+          - image: lemon-ipw-middleware
+            context: middleware-go
+            runner: ubuntu-24.04-arm
+            platforms: linux/arm/v7
+            platform_id: armv7
+    steps:
+      - name: Checkout repository
+        uses: actions/checkout@v4
+
+      - name: Set up Docker Buildx
+        uses: docker/setup-buildx-action@v3
+
+      - name: Log in to GHCR
+        uses: docker/login-action@v3
+        with:
+          registry: ghcr.io
+          username: ${{ github.actor }}
+          password: ${{ secrets.GITHUB_TOKEN }}
+
+      - name: Docker meta
+        id: meta
+        uses: docker/metadata-action@v5
+        with:
+          images: ghcr.io/${{ github.repository }}/${{ matrix.image }}
+
+      # push-by-digest 模式：不传 tags（新 buildx 禁止 tagged ref 按 digest 推送），
+      # 仓库名通过 outputs 的 name= 传入，最终 tag 由 merge 阶段统一打
+      - name: Build and push by digest
+        id: build
+        uses: docker/build-push-action@v6
+        with:
+          context: ${{ matrix.context }}
+          platforms: ${{ matrix.platforms }}
+          labels: ${{ steps.meta.outputs.labels }}
+          outputs: type=image,name=ghcr.io/${{ github.repository }}/${{ matrix.image }},push-by-digest=true,name-canonical=true,push=true
+          cache-from: type=gha,scope=${{ matrix.image }}-${{ matrix.platform_id }}
+          cache-to: type=gha,mode=max,scope=${{ matrix.image }}-${{ matrix.platform_id }}
+
+      - name: Export digest
+        run: |
+          mkdir -p "${{ runner.temp }}/digests"
+          digest="${{ steps.build.outputs.digest }}"
+          # 文件名自带镜像与平台元数据：merge 阶段 merge-multiple 平铺下载后
+          # 按前缀收集，不依赖 artifact 的目录结构
+          touch "${{ runner.temp }}/digests/${{ matrix.image }}-${{ matrix.platform_id }}-${digest#sha256:}"
+
+      - name: Upload digest
+        uses: actions/upload-artifact@v4
+        with:
+          name: digests-${{ matrix.image }}-${{ matrix.platform_id }}
+          path: ${{ runner.temp }}/digests/*
+          if-no-files-found: error
+          retention-days: 1
+
+  merge:
+    runs-on: ubuntu-latest
+    needs: build
+    steps:
+      - name: Download digests
+        uses: actions/download-artifact@v4
+        with:
+          path: ${{ runner.temp }}/digests
+          pattern: digests-*
+          merge-multiple: true
+
+      - name: Set up Docker Buildx
+        uses: docker/setup-buildx-action@v3
+
+      - name: Log in to GHCR
+        uses: docker/login-action@v3
+        with:
+          registry: ghcr.io
+          username: ${{ github.actor }}
+          password: ${{ secrets.GITHUB_TOKEN }}
+
+      # ===== Docker Hub 推送暂时停用 =====
+      # 需要启用时：取消注释本步骤与下方 merge 脚本中的 docker.io 标签行，
+      # 并在仓库 Secrets 配置 DOCKERHUB_USERNAME / DOCKERHUB_TOKEN
+      # - name: Log in to Docker Hub
+      #   if: ${{ secrets.DOCKERHUB_USERNAME != '' }}
+      #   uses: docker/login-action@v3
+      #   with:
+      #     username: ${{ secrets.DOCKERHUB_USERNAME }}
+      #     password: ${{ secrets.DOCKERHUB_TOKEN }}
+
+      - name: Create and push multi-arch manifest lists
+        # DOCKERHUB_USERNAME 暂不注入（Docker Hub 推送停用，见上方登录步骤注释）
+        # env:
+        #   DOCKERHUB_USERNAME: ${{ secrets.DOCKERHUB_USERNAME }}
+        run: |
+          set -euo pipefail
+          DIGESTS_DIR="${{ runner.temp }}/digests"
+          GHCR_REPO="ghcr.io/${GITHUB_REPOSITORY,,}"
+
+          # 标签：v1.2.3 → ["1.2.3", "1.2"]；手动触发 → ["main"]
+          if [[ "${GITHUB_REF_NAME}" == v* ]]; then
+            VERSION="${GITHUB_REF_NAME#v}"
+            MINOR="$(echo "${VERSION}" | cut -d. -f1,2)"
+            TAGS=("${VERSION}" "${MINOR}")
+          else
+            TAGS=("main")
+          fi
+
+          for IMG in lemon-ipw lemon-ipw-middleware; do
+            ARGS=()
+            for TAG in "${TAGS[@]}"; do
+              ARGS+=(-t "${GHCR_REPO}/${IMG}:${TAG}")
+              # Docker Hub 推送停用；启用时取消注释并恢复上方 DOCKERHUB_USERNAME env
+              # if [ -n "${DOCKERHUB_USERNAME}" ]; then
+              #   ARGS+=(-t "docker.io/${DOCKERHUB_USERNAME,,}/${IMG}:${TAG}")
+              # fi
+            done
+            # 各平台单架构 manifest（GHCR 上按 digest 推送的产物）合并为一份
+            # 多架构 manifest list；imagetools create 会按 -t 目标推送到 GHCR
+            shopt -s nullglob
+            for PLATFORM_ID in amd64 arm64 armv7; do
+              PREFIX="${IMG}-${PLATFORM_ID}-"
+              FILES=("${DIGESTS_DIR}"/${PREFIX}*)
+              if [ ${#FILES[@]} -eq 0 ]; then
+                echo "ERROR: no digest file for ${IMG} (${PLATFORM_ID}); dir contents:" >&2
+                ls -la "${DIGESTS_DIR}" >&2 || true
+                exit 1
+              fi
+              for f in "${FILES[@]}"; do
+                hex="$(basename "${f}")"
+                ARGS+=("${GHCR_REPO}/${IMG}@sha256:${hex#${PREFIX}}")
+              done
+            done
+            shopt -u nullglob
+            echo "Merging ${#ARGS[@]} refs for ${IMG}:"; printf '  %s\n' "${ARGS[@]}"
+            docker buildx imagetools create "${ARGS[@]}"
+          done
+          echo "Pushed multi-arch manifests: ${TAGS[*]}"

.github/workflows/edgeone-backend.yml

@@ -5,7 +5,7 @@ on:
     branches:
       - main
     paths:
-      - 'edgeone/**'
+      - 'serverless/edgeone/**'
   workflow_dispatch:
 
 jobs:
@@ -24,10 +24,10 @@ jobs:
       - name: Install dependencies
         run: npm install -g edgeone
       - name: Deploy to EdgeOne Pages
-        run: cd edgeone && npx edgeone pages deploy -n ipw-cn -t ${{ secrets.EDGEONE_API_TOKEN }}
+        run: cd serverless/edgeone && npx edgeone pages deploy -n ipw-cn -t ${{ secrets.EDGEONE_API_TOKEN }}
         env:
           EDGEONE_API_TOKEN: ${{ secrets.EDGEONE_API_TOKEN }}
       - name: Deploy to EdgeOne Pages
-        run: cd edgeone && npx edgeone pages deploy -n ipw-cn2 -t ${{ secrets.EDGEONE_API_TOKEN }}
+        run: cd serverless/edgeone && npx edgeone pages deploy -n ipw-cn2 -t ${{ secrets.EDGEONE_API_TOKEN }}
         env:
           EDGEONE_API_TOKEN: ${{ secrets.EDGEONE_API_TOKEN }}

.github/workflows/edgeone-getip.yml

@@ -5,7 +5,7 @@ on:
     branches:
       - main
     paths:
-      - 'edgeone-getip/**'
+      - 'serverless/edgeone-getip/**'
   workflow_dispatch:
 
 jobs:
@@ -24,6 +24,6 @@ jobs:
       - name: Install dependencies
         run: npm install -g edgeone
       - name: Deploy to EdgeOne Pages
-        run: cd edgeone-getip && npx edgeone pages deploy -n edgeone-getip -t ${{ secrets.EDGEONE_API_TOKEN }}
+        run: cd serverless/edgeone-getip && npx edgeone pages deploy -n edgeone-getip -t ${{ secrets.EDGEONE_API_TOKEN }}
         env:
           EDGEONE_API_TOKEN: ${{ secrets.EDGEONE_API_TOKEN }}

.github/workflows/workers.yml

@@ -4,7 +4,7 @@ on:
   push:
     branches: ['main']
     paths:
-      - 'lemon-getip/**'
+      - 'serverless/lemon-getip/**'
   workflow_dispatch:
 jobs:
   deploy:
@@ -25,6 +25,6 @@ jobs:
           CLOUDFLARE_API_TOKEN: ${{ secrets.CLOUDFLARE_API_TOKEN }}
           CLOUDFLARE_ACCOUNT_ID: ${{ secrets.CLOUDFLARE_ACCOUNT_ID }}
         run: |
-          cd lemon-getip
+          cd serverless/lemon-getip
           npm install
           npm run deploy

.gitignore

@@ -15,9 +15,11 @@ lemon-ipw
 *.tmp
 *.log
 node_modules/
-setting.json
 .workbuddy/
 # VitePress 构建产物
 docs/.vitepress/.temp/
 docs/.vitepress/cache/
-docs/.vitepress/dist/
+docs/.vitepress/dist/
+tmp/
+setting.json
+*.BIN

Dockerfile

@@ -1,31 +0,0 @@
-FROM golang:1.26-alpine AS build
-ENV GO111MODULE=on \
-    CGO_ENABLED=0 \
-    GOOS=linux \
-    GOARCH=amd64
-WORKDIR /app
-COPY go.mod go.sum ./
-RUN go mod download
-COPY main.go ./
-COPY webtest/ ./webtest/
-COPY ipdb/ ./ipdb/
-COPY ssrf/ ./ssrf/
-RUN go build -o main .
-
-# 运行阶段
-FROM alpine:latest
-
-# 添加必要的证书
-RUN apk --no-cache add ca-certificates
-
-# 创建非root用户
-RUN adduser -D appuser
-USER appuser
-
-WORKDIR /home/appuser
-
-# 从构建阶段复制二进制文件
-COPY --from=build /app/main .
-
-EXPOSE 8080
-CMD ["./main"]

README.md

@@ -7,7 +7,7 @@ ipw.cn 替代品，提供 IP 查询、网站检测、SSL 检查、DNS 解析、T
 ## 快速开始
 
 ```bash
-curl -o- https://cdn.jsdelivr.net/gh/nomdn/ipw-cn@main/install.sh | bash
+curl -fsSL https://raw.githubusercontent.com/nomdn/ipw-cn/main/install.sh -o install.sh && sudo bash install.sh
 ```
 
 完整部署（后端节点 / 独立中间件 / 前端）与配置说明见 [文档](https://github.com/nomdn/ipw-cn/tree/main/docs)：
@@ -22,16 +22,18 @@ curl -o- https://cdn.jsdelivr.net/gh/nomdn/ipw-cn@main/install.sh | bash
 
 ```
 ipw-cn/
-├── main.go            # Go 后端入口（Gin，自托管）
-├── middleware-go/     # 独立转发中间件（Fiber v3，多节点候选）
+├── src/               # Go 后端
+├── middleware-go/     # 独立组件 转发中间件（Fiber v3，多节点候选）
+├── serverless/        # 独立组件 边缘/Serverless（edgeone、edgeone-getip、lemon-getip）
 ├── frontend-ssr/      # Nuxt 4 SSR 前端
-├── edgeone/           # 腾讯 EdgeOne 边缘函数后端
-├── webtest/           # 网络测试工具库
-├── ipdb/              # IP 数据库模块
-├── ssrf/              # SSRF 防护
 ├── docs/              # 文档站
 └── install.sh         # 一键安装脚本
 ```
+## 友情链接
+### 来自社区的IPW版本
+[ZAKOFLARE/ipw-cn-php](https://github.com/ZAKOFLARE/ipw-cn-php) 一个基于PHP的IPW节点   
+[ZAKOFLARE/ipw-cn-rust](https://github.com/ZAKOFLARE/ipw-cn-rust) 一个生锈的IPW节点[开发成本过高,已存档]  
+[KFCV50TK/ipw-cn](https://github.com/KFCV50TK/ipw-cn) 一个有许多扩展功能的IPW分支  
 
 ## 技术栈
 

docs/guide/config.md

@@ -13,19 +13,27 @@
     "block-private-ips": true,
     "ipdb": true,
     "cors": "",
-    "access_token": ""
+    "access-token": ""
 }
 ```
 
 - `port`：监听端口
-- `dns-server`：DNS 解析服务器，支持**主从 failover**——逗号分隔多地址（如 `"119.28.28.28:53,223.5.5.5:53"`），第一个为主，主查询失败（超时/网络错误）自动切换下一个；每项支持 `ip:port`（UDP）或 `https://` URL（DoH）
-- `dnssec-server`：**DNSSEC 专用** DNS 服务器（同样支持主从逗号分隔）；留空则沿用 `dns-server`
+- `dns-server`：DNS 解析服务器，支持**主从 failover**——逗号分隔多地址（如 `"119.28.28.28:53,223.5.5.5:53"`），第一个为主，主查询失败（超时/网络错误）自动切换下一个；每项支持 `ip:port`（UDP）或 `https://` URL（DoH）；**留空则启动时自动探测系统 DNS**（`IP:Port` 逗号分隔串）兜底
+- `dnssec-server`：**DNSSEC 专用** DNS 服务器（同样支持主从逗号分隔）；留空则沿用 `dns-server`；`dns-server` 与 `dnssec-server` **都留空时自动探测系统 DNS** 兜底
 - `block-private-ips`：SSRF 防护开关
-- `ipdb`：IP 数据库开关（首次启动自动下载约 200MB，之后每 24h 更新）
+- `ipdb`：IP 数据库开关（首次启动自动下载约 450MB，之后每 24h 更新）
 - `cors`：允许的请求来源（逗号分隔）
-- `access_token`：API 访问令牌，留空则不启用鉴权
+- `trusted-proxies`：可信代理 IP/CIDR（逗号分隔，如 `"10.0.0.0/8,173.245.48.0/20"`）。配置后 `ClientIP` 与 `/v1/location` 归属地接口只信任这些代理转发的 `X-Forwarded-For`，直连公网的节点可防止访客伪造 XFF；**留空保持默认行为（信任所有代理，XFF 可被伪造）**
+- `access-token`：API 访问令牌，留空则不启用鉴权
+- `ws-url`：WS 通道地址——接入独立中间件的 WebSocket 地址（如 `"wss://middleware-1.api-ipw.wsmdn.top/ws"`，须含 `wss://` 前缀与 `/ws` 路径）；支持**逗号分隔多个中间件，同时连接全部（多活）**，任一断开只重连自己，不影响其他连接；留空 = 不启用 WS 客户端，走原 HTTP 接口
+- `node-id`：WS 节点 id（与中间件 `api-keys`/`ws-keys` 键、前端配置的节点 `id` 一致；建议用 UUID 唯一标识）
+- `node-key`：WS 注册 key（与中间件 `ws-keys[节点id]` 一致；**必填**——节点未配置该 key 时中间件拒绝注册并返回 401）
+- `node-ota`：**OTA 自更新开关**（`"true"` 启用）。启用后节点定期检查本仓库 GitHub Release，发现新版本时下载与当前平台匹配的二进制、**替换自身并重启**（旧二进制保留为 `<程序名>.old` 便于回滚）；默认关闭
+- `report-url`：**数据上报收集中心** HTTP 基址（如 `"https://collector.example.com"`，即 ipw-boce 中间件）。节点把自身观测的统计/拨测按 `report-interval-seconds` 周期上报；`ws-url` 已启用时优先走 WS `report` 消息（所有已连接中间件广播），WS 未启用或全部掉线时 HTTP POST 到 `<report-url>/report` 兜底；远端配置可覆盖（`report-ignore-config` 加 `report-url` 可禁止）
+- `report-token`：收集中心 `/report` 鉴权 token（与中间件 `report-token` 配置一致）；属敏感凭据，**不随远端配置覆盖**
+- `report-interval-seconds`：上报周期秒，缺省 15
 
-以上字段均可用环境变量覆盖（`PORTS` / `DNS_SERVER` / `DNSSEC_DNS_SERVER` / `BLOCK_PRIVATE_IPS` / `IPDB` / `CORS` / `ACCESS_TOKEN`）。需要从远端拉取配置时，设置 `remote-config-url` 或环境变量 `REMOTE_CONFIG_URL`（优先级：远端 > 环境变量 > setting.json）。
+以上字段均可用环境变量覆盖（`PORTS` / `DNS_SERVER` / `DNSSEC_DNS_SERVER` / `BLOCK_PRIVATE_IPS` / `IPDB` / `CORS` / `TRUSTED_PROXIES` / `ACCESS_TOKEN` / `WS_URL` / `NODE_ID` / `NODE_KEY` / `NODE_OTA` / `REPORT_URL` / `REPORT_TOKEN` / `REPORT_INTERVAL_SECONDS`）。需要从远端拉取配置时，设置 `remote-config-url` 或环境变量 `REMOTE_CONFIG_URL`（优先级：远端 > 环境变量 > setting.json）。
 
 ---
 
@@ -44,11 +52,8 @@
 | `ICP` / `GongAn` | string | 网站备案号（页脚展示） |
 | `noindex` | boolean | 全站是否禁止搜索引擎索引 |
 | `v4OnlyAPI` / `v6OnlyAPI` / `DualStackAPI` | string | IPv4 / IPv6 / 双栈 IP 查询接口 |
-| `apiBaseUrls` | 节点数组 | 基础 API 节点列表（detail / ssl / whois 等） |
-| `IPLocationAPIs` | 节点数组 | IP 归属地 / ASN 查询节点列表 |
-| `TCPing` | 节点分组 | TCPing 节点，按 `DualStack` / `IPv4` / `IPv6` 分组 |
-| `SpeedTest` | 节点分组 | 测速节点，按 `DualStack` / `IPv4` / `IPv6` 分组 |
-| `NSLookup` | 节点数组 | DNS 解析节点列表 |
+| `APIBaseURL` | 节点池 | 拨测上游节点池（whois / ssl / detail / dns / dnssec / tcping / speed），含 `DualStack` / `IPv4` / `IPv6` 三栈 |
+| `IPLocationAPI` | 节点数组 | IP 归属地 / ASN 查询节点池（纯数组，无栈区分） |
 
 完整模板（复制到 `frontend-ssr/config/index.ts`，替换占位值即可）：
 
@@ -75,49 +80,38 @@ const config = {
     v4OnlyAPI: "https://4.wsmdn.top",
     v6OnlyAPI: "https://6.wsmdn.top",
     DualStackAPI: "https://test.wsmdn.top",
-    // 基础 API 节点（detail / ssl / whois 等）
-    apiBaseUrls: [
-        { label: "节点显示名", id: "node-1", url: "https://node-1.example.com/" }
-    ],
-    // IP 归属地 / ASN 查询节点
-    IPLocationAPIs: [
-        { label: "节点显示名", id: "node-1", url: "https://node-1.example.com/" }
-    ],
-    // TCPing 节点：IPv4-only 节点只能放 IPv4 分组，不能放 DualStack / IPv6
-    TCPing: {
+    // 拨测节点池（whois / ssl / detail / dns / dnssec / tcping / speed）
+    // IPv4-only 节点只能放 IPv4 栈，IPv6-only 放 IPv6 栈，双栈放 DualStack
+    APIBaseURL: {
         DualStack: [],
         IPv4: [
             { label: "节点显示名", id: "node-1", url: "https://node-1.example.com/" }
         ],
         IPv6: []
     },
-    // 测速节点：同上，IPv4-only 节点只能放 IPv4 分组
-    SpeedTest: {
-        DualStack: [],
-        IPv4: [
-            { label: "节点显示名", id: "node-1", url: "https://node-1.example.com/" }
-        ],
-        IPv6: []
-    },
-    // DNS 解析节点
-    NSLookup: [
+    // IP 归属地 / ASN 查询节点池（纯数组，无栈区分）
+    IPLocationAPI: [
         { label: "节点显示名", id: "node-1", url: "https://node-1.example.com/" }
     ]
 }
 export { config }
 ```
 
-> 节点 `id` 需与后端节点 / 中间件 `apiKeys` 的键保持一致，中间件按 `id` 注入 `Authorization: Bearer <key>`。
+> 节点 `id` 需与后端节点 / 中间件 `api-keys` 的键保持一致，中间件按 `id` 注入 `Authorization: Bearer <key>`；WS 通道的节点注册校验另见中间件 `ws-keys`（与后端 `node-key` 对应）。
 
 节点数组项均为 `{ label, id, url }` 结构，例如：
 
 ```ts
-apiBaseUrls: [
-    { label: "中国 江苏 移动", id: "cn-jiangsu", url: "https://cn-jiangsu.api-ipw.wsmdn.top/" }
-]
+APIBaseURL: {
+    DualStack: [
+        { label: "中国 江苏 移动", id: "cn-jiangsu", url: "https://cn-jiangsu.api-ipw.wsmdn.top/" }
+    ],
+    IPv4: [],
+    IPv6: []
+}
 ```
 
-`label` 为节点展示名，`id` 为节点唯一标识（中间件 `apiKeys` 也按此 id 注入 key），`url` 为节点 base URL。`TCPing` / `SpeedTest` 节点再多一层 `DualStack` / `IPv4` / `IPv6` 分组，分别对应双栈 / 单栈测试时使用的节点列表。
+`label` 为节点展示名，`id` 为节点唯一标识（中间件 `api-keys` 按此 id 注入 HTTP 转发 key，WS 注册校验另见 `ws-keys`），`url` 为节点 base URL。节点池结构如下：`APIBaseURL` 为拨测节点池，含 `DualStack` / `IPv4` / `IPv6` 三栈（分别对应双栈 / 单栈测试时使用的节点列表，IPv4-only 节点只能放 `IPv4` 栈，IPv6-only 只能放 `IPv6` 栈，不能放 `DualStack`）；`IPLocationAPI` 为 IP 归属地 / ASN 查询节点池，为纯数组（无栈区分）。
 
 ### 出站 IP 检测接口（v4OnlyAPI / v6OnlyAPI / DualStackAPI）
 
@@ -150,6 +144,22 @@ apiBaseUrls: [
 
 也可以在 `nuxt.config.ts` 的 `runtimeConfig.apiKeys` 里直接写死（不推荐，密钥不应进仓库）。
 
+### 内置中间件数据上报（调一次上报一次）
+
+内置中间件可作为数据上报入口：每转发一次请求，向收集中心（ipw-boce 中间件）`POST /report` 上报一次统计与拨测明细。**配置全部经环境变量注入**（敏感项不进仓库）：
+
+| 环境变量 | 说明 |
+|------|------|
+| `NUXT_BOCE_REPORT_URL` | 收集中心基址（如 `https://collector.example.com`）；**留空 = 不上报**（此时转发也不带标记头，由节点兜底记账） |
+| `NUXT_BOCE_REPORT_TOKEN` | 收集中心 `/report` 鉴权 token（敏感，与收集中心 `report-token` 配置一致） |
+| `NUXT_BOCE_REPORT_INSTANCE` | 上报方标识（存收集库 `probe_results.origin`）；默认 `frontend-ssr` |
+
+行为约定：
+
+- 配置了上报后，内置中间件转发请求会带 `X-Boce-Reporter` 标记头——后端节点据此跳过这些请求的统计（防双算，见后端节点"数据上报"一节）
+- 上报为 fire-and-forget：失败静默丢弃、不重试（统计是增量累加语义，重试会双算），不影响转发响应
+- 上报失败不影响主链路；超时 5 秒
+
 ---
 
 ## 独立中间件（middleware-go）
@@ -161,21 +171,56 @@ apiBaseUrls: [
     "port": "8091",
     "http-timeout-seconds": 30,
     "cors": "",
+    "trusted-proxies": "",
+    "gh-proxy": "",
+    "ota": "false",
     "rate-limit": 120,
     "ws-port": 8092,
     "remote-config-url": "",
-    "remote-ingore-config": [],
-    "apiBaseUrls": [ { "label": "中国 江苏 移动", "id": "cn-jiangsu", "url": "https://cn-jiangsu.api-ipw.wsmdn.top/" } ],
-    "apiKeys": { "cn-jiangsu": "" }
+    "remote-ignore-config": [],
+    "api-base-url": {
+        "DualStack": [ { "label": "中国 江苏 移动", "id": "cn-jiangsu", "url": "https://cn-jiangsu.api-ipw.wsmdn.top/" } ],
+        "IPv4": [],
+        "IPv6": []
+    },
+    "ip-location-api": [ { "label": "中国 江苏 移动", "id": "cn-jiangsu", "url": "https://cn-jiangsu.api-ipw.wsmdn.top/" } ],
+    "api-keys": { "cn-jiangsu": "" },
+    "ws-keys": { "cn-jiangsu": "" }
 }
 ```
 
 - `rate-limit`：单 IP 每分钟限流次数，默认 `120`，`0` 表示不限流（也可用环境变量 `RATE_LIMIT` 覆盖）
+- `trusted-proxies`：可信代理 IP/CIDR（逗号分隔）。配置后 `c.IP()`（限流按它分桶）只信任这些代理转发的 `X-Forwarded-For`，反代/CDN 后限流才按真实客户端 IP 计数；留空保持默认（不信任 XFF 头，按直连地址限流）。也可用环境变量 `TRUSTED_PROXIES` 覆盖
+- `gh-proxy`：GitHub 代理前缀（OTA 下载加速，如 `"https://ghproxy.com/"`），可空；也可用环境变量 `GH_PROXY` 覆盖
+- `ota`：**OTA 自更新开关**（`"true"` 启用）。启用后中间件定期检查本仓库 GitHub Release，发现新版本时下载匹配的 `middleware-go-*` 资产、预检、**替换自身并重启**（Windows 下为优雅交接，失败自动回滚旧版；major 版本升级需人工）；默认关闭。也可用环境变量 `OTA` 覆盖
 - `ws-port`：WS 服务端口，默认 `8092`，`0` 表示关闭 WS 通道（也可用环境变量 `WS_PORT` 覆盖；优先级：远端配置 > 环境变量 > setting.json）
 - `remote-config-url`：远端配置地址，也可用环境变量 `REMOTE_CONFIG_URL`（环境变量优先）
-- `remote-ingore-config`：**不被远端配置覆盖的配置项列表**（数组），如 `["port", "rate-limit"]`；也可用环境变量 `REMOTE_INGORE_CONFIG`（JSON 数组字符串，优先于 setting.json）
-- `apiKeys`：用于向后端注入 `Authorization: Bearer <key>`，优先级：setting.json `apiKeys` > 环境变量 `APIKEYS`（JSON 字符串）。**敏感凭据，强制忽略，不随远端配置覆盖**
-- 节点数组项（`apiBaseUrls` / `IPLocationAPIs` / `TCPing` / `SpeedTest` / `NSLookup`）与前端 `config/index.ts` 结构一致；节点加 `"ws": true` 可让该节点走 WS 通道通信，详见 [中间件部署 - WS 通道](/guide/deploy-middleware#ws-通道拨测数据经-websocket-传输)
+- `remote-ignore-config`：**不被远端配置覆盖的配置项列表**（数组），如 `["port", "rate-limit"]`；也可用环境变量 `REMOTE_IGNORE_CONFIG`（JSON 数组字符串，优先于 setting.json）
+- `api-keys`：用于向后端注入 `Authorization: Bearer <key>`，优先级：setting.json `api-keys` > 环境变量 `API_KEYS`（JSON 字符串）。**敏感凭据，强制忽略，不随远端配置覆盖**
+- `ws-keys`：WS 注册校验表（`节点id → key`）：节点经 WS 注册时，`register` 消息的 `key` 必须与 `ws-keys[节点id]` 一致，否则返回 401 并断开；优先级：setting.json `ws-keys` > 环境变量 `WS_KEYS`（JSON 字符串）。**敏感凭据，强制忽略，不随远端配置覆盖**。与 `api-keys` **相互独立**——`api-keys` 管 HTTP 转发鉴权，`ws-keys` 管 WS 注册校验，可分别配置不同 key（例如 WS 节点单独换 key 不影响 HTTP 转发）
+- 节点池与前端 `config/index.ts` 结构一致：`APIBaseURL` 为拨测节点池（含 `DualStack` / `IPv4` / `IPv6` 三栈），`IPLocationAPI` 为 IP 归属地 / ASN 节点池（纯数组，无栈）；节点加 `"ws": true` 可让该节点走 WS 通道通信，详见 [中间件部署 - WS 通道](/guide/deploy-middleware#ws-通道拨测数据经-websocket-传输)
+
+### WS 通道配置一览
+
+WS 通道涉及**中间件（服务端）**与**后端节点（客户端）**两侧配置：
+
+| 角色 | 配置项 | 环境变量 | 说明 |
+|------|--------|----------|------|
+| 中间件（服务端） | `ws-port` | `WS_PORT` | WS 监听端口，默认 `8092`，`0`=关闭；节点连 `ws(s)://<中间件>:<ws-port>/ws` |
+| 中间件（服务端） | `ws-keys` | `WS_KEYS` | WS 注册校验表：`{"<node-id>": "<key>"}`，节点 `register` 的 key 必须匹配 |
+| 节点（客户端） | `ws-url` | `WS_URL` | 中间件 WS 完整地址（含 `/ws` 路径），逗号分隔多个则**同时连接全部（多活）** |
+| 节点（客户端） | `node-id` | `NODE_ID` | 节点 id，与中间件 `api-keys`/`ws-keys` 键一致（建议 UUID） |
+| 节点（客户端） | `node-key` | `NODE_KEY` | 注册 key，与中间件 `ws-keys[节点id]` 一致，**必填** |
+
+**数据上报通道**（节点把自身观测的统计/拨测上报到收集中心，归属规则防双算——中间件转发的请求由中间件上报，节点只报直连/前端/边缘流量）：
+
+| 角色 | 配置项 | 环境变量 | 说明 |
+|------|--------|----------|------|
+| 节点（客户端） | `report-url` | `REPORT_URL` | 收集中心（ipw-boce 中间件）HTTP 基址；WS 在线时优先走 WS 广播，掉线时 POST `<report-url>/report` 兜底 |
+| 节点（客户端） | `report-token` | `REPORT_TOKEN` | `/report` 鉴权 token，与收集中心 `report-token` 一致；**不随远端配置覆盖** |
+| 节点（客户端） | `report-interval-seconds` | `REPORT_INTERVAL_SECONDS` | 上报周期秒，缺省 15 |
+
+**链路**：中间件收到 `ws:true` 节点的拨测请求 → 经 WS 发 `probe` → 节点执行探针（直调 webtest 函数 + 缓存）→ `probe_result` 回传 → 中间件返回 HTTP 响应（`Content-Type: application/json`）。节点侧接入步骤见 [后端节点部署 - WS 通道接入](/guide/deploy-node#ws-通道接入可选)。
 
 ---
 
@@ -187,8 +232,8 @@ apiBaseUrls: [
 
 | 组件 | 触发方式 | 远端配置格式 |
 |------|----------|--------------|
-| 后端（主线 `main.go`） | `REMOTE_CONFIG_URL` 或 setting.json 的 `remote-config-url` | 后端 `setting.json` 格式 |
-| 后端（`edgeone/`） | `REMOTE_CONFIG_URL` | 后端 `setting.json` 格式 |
+| 后端（主线 `src/main.go`） | `REMOTE_CONFIG_URL` 或 setting.json 的 `remote-config-url` | 后端 `setting.json` 格式 |
+| 后端（`serverless/edgeone/`） | `REMOTE_CONFIG_URL` | 后端 `setting.json` 格式 |
 | 独立中间件（middleware-go） | `REMOTE_CONFIG_URL` 或 setting.json 的 `remote-config-url` | 中间件 `setting.json` 格式 |
 
 **合并规则**（重要，逐字段生效）：
@@ -197,9 +242,9 @@ apiBaseUrls: [
 - 远端 JSON 中**非空的字段才覆盖**本地值：字符串非空、数组非空、数字非 0（`rate-limit` 为指针语义，缺省=不覆盖，显式 0=不限流）
 - 部分字段缺省不会冲掉本地配置——远端只需包含要覆盖的字段
 - **敏感凭据强制忽略，永远不被远端覆盖**（代码写死，无需配置）：
-  - 后端 `access_token`：不随远端覆盖（保持 环境变量 > setting.json），远端里的 `access_token` 会被忽略
-  - 中间件 `apiKeys`：不随远端覆盖，远端里的 `apiKeys` 会被忽略
-- `remote-ingore-config`（后端键名 `remote-ingore-config` / env `REMOTE_INGORE_CONFIG`）：额外指定**不被远端覆盖的配置项列表**，数组中的键即使远端下发也不生效。适用于 access_token / apiKeys 之外的敏感项（如 `node-key`、`dns-server` 等），也可覆盖"非空才覆盖"规则
+  - 后端 `access-token`：不随远端覆盖（保持 环境变量 > setting.json），远端里的 `access-token` 会被忽略
+  - 中间件 `api-keys` / `ws-keys`：不随远端覆盖，远端里的 `api-keys`/`ws-keys` 会被忽略
+- `remote-ignore-config`（后端键名 `remote-ignore-config` / env `REMOTE_IGNORE_CONFIG`）：额外指定**不被远端覆盖的配置项列表**，数组中的键即使远端下发也不生效。适用于 access-token / api-keys / ws-keys 之外的敏感项（如 `node-key`、`dns-server` 等），也可覆盖"非空才覆盖"规则
 
 **拉取行为**：
 
@@ -233,12 +278,18 @@ REMOTE_CONFIG_URL=https://example.com/ipw-config.json ./lemonipw
 {
     "port": "8091",
     "cors": "",
+    "trusted-proxies": "",
     "rate-limit": 120,
-    "apiBaseUrls": [ { "label": "中国 江苏 移动", "id": "cn-jiangsu", "url": "https://cn-jiangsu.api-ipw.wsmdn.top/" } ]
+    "api-base-url": {
+        "DualStack": [ { "label": "中国 江苏 移动", "id": "cn-jiangsu", "url": "https://cn-jiangsu.api-ipw.wsmdn.top/" } ],
+        "IPv4": [],
+        "IPv6": []
+    }
 }
 ```
 
-> **⚠️ 敏感凭据不得上传远端**：`apiKeys`（及后端 `access_token`、节点 key 等密钥）**禁止**写入远端配置——即使写了也会被强制忽略。凭据只放本地 setting.json 或环境变量。
+> [!WARNING]
+> 敏感凭据不得上传远端：`api-keys`/`ws-keys`（及后端 `access-token`、节点 key 等密钥）**禁止**写入远端配置——即使写了也会被强制忽略。凭据只放本地 setting.json 或环境变量。
 
 部署时：
 
@@ -256,7 +307,7 @@ systemd 中同样用 `Environment="REMOTE_CONFIG_URL=..."` 配置。
 
 **安全与排查**：
 
-- **⚠️ 敏感凭据不得上传远端**：远端配置（Gist / 对象存储 / 静态托管等）**禁止包含任何密钥**——`apiKeys`、`access_token`、节点 key（`node-key`）等。这些值会被强制忽略，但远端文件本身一旦泄露等于直接暴露凭据；凭据一律放本地 `setting.json` 或环境变量注入
+- **敏感凭据不得上传远端**：远端配置（Gist / 对象存储 / 静态托管等）**禁止包含任何密钥**——`api-keys`/`ws-keys`、`access-token`、节点 key（`node-key`）等。这些值会被强制忽略，但远端文件本身一旦泄露等于直接暴露凭据；凭据一律放本地 `setting.json` 或环境变量注入
 - 远端 URL 必须能被节点访问；优先使用 **HTTPS** 地址
 - 远端配置文件如果放在公开可访问的位置（公开 Gist、无鉴权对象存储），即便不含密钥，也等于把节点拓扑、节点 id 等敏感信息公之于众，建议放在私有仓库 / 带鉴权的对象存储 / 内部服务上
 - 常见失败排查：

docs/guide/deploy-frontend.md

@@ -32,9 +32,8 @@ pnpm dev
 |--------|------|
 | `siteUrl` | 站点对外地址 |
 | `siteName` | 站点名称（页面标题 / 描述 / 页脚品牌） |
-| `apiBaseUrls` | 后端上游节点列表（whois / ssl / detail） |
-| `IPLocationAPIs` | IP 归属地 / ASN 上游节点列表 |
-| `TCPing` / `SpeedTest` / `NSLookup` | 对应功能的多节点候选（DualStack / IPv4 / IPv6） |
+| `APIBaseURL` | 拨测上游节点池（whois / ssl / detail / dns / dnssec / tcping / speed），含 `DualStack` / `IPv4` / `IPv6` 三栈 |
+| `IPLocationAPI` | IP 归属地 / ASN 上游节点池（纯数组，无栈区分） |
 | `Middleware` | 外部独立中间件 base URL 列表，`/middleware/*` 请求依次尝试、失败重试下一个 |
 | `EnableInternalMiddleware` | 是否启用前端内置中间件（本地转发，作为候选列表最后一位兜底），默认 `true` |
 | `rateLimitPerMinute` | 内置中间件单 IP 限流次数（次/分钟），默认 `120`，`0` 表示不限流 |

docs/guide/deploy-middleware.md

@@ -13,21 +13,32 @@
 > cp middleware.setting.json.example setting.json
 > ```
 >
-> 复制后按需修改 `apiBaseUrls` / `apiKeys` / `cors` 等配置项。
+> 复制后按需修改 `api-base-url` / `ip-location-api` / `api-keys` / `ws-keys` / `cors` 等配置项。
 
 ## 方案一：Docker
 
-`middleware-go/` 目录提供 `Dockerfile`：
+`middleware-go/` 目录提供 `Dockerfile`（多阶段构建，产物基于 Alpine，支持多架构）：
 
 ```bash
 cd middleware-go
 docker build -t middleware-go .
 docker run -d -p 8091:8091 \
-  -v $(pwd)/setting.json:/app/setting.json \
+  -v $(pwd)/setting.json:/home/appuser/setting.json \
   middleware-go
 ```
 
-配置通过挂载 `setting.json` 提供（`apiBaseUrls` / `apiKeys` / `cors` / `rate-limit` / `remote-config-url` 等；`rate-limit` 为单 IP 每分钟限流次数，默认 120，0 表示不限流，可用环境变量 `RATE_LIMIT` 覆盖；`remote-config-url` 为远端配置地址，可用环境变量 `REMOTE_CONFIG_URL` 覆盖；**`apiKeys` 为敏感凭据，不随远端配置覆盖**）。
+> 配置挂载注意：容器工作目录是 `/home/appuser`（非 root 用户运行），`setting.json` 要挂到这个路径下。
+
+**多架构**：Dockerfile 已适配 buildx 交叉编译，本机构建其他架构：
+
+```bash
+cd middleware-go
+docker buildx build --platform linux/arm64 -t middleware-go:arm64 --load .
+```
+
+打 `v*` 版本标签发版时，CI 会自动构建 `linux/amd64` / `linux/arm64` / `linux/arm/v7` 三架构镜像（amd64 原生构建，arm64/armv7 在 GitHub 原生 ARM 实例上交叉构建，无 QEMU），推送 GHCR（`ghcr.io/<owner>/<repo>/lemon-ipw-middleware`；Docker Hub 推送在 workflow 中暂未启用，预留了注释可随时开启），Docker 按宿主机架构自动拉取对应变体。
+
+配置通过挂载 `setting.json` 提供（`api-base-url` / `ip-location-api` / `api-keys` / `ws-keys` / `cors` / `trusted-proxies` / `rate-limit` / `remote-config-url` 等；`rate-limit` 为单 IP 每分钟限流次数，默认 120，0 表示不限流，可用环境变量 `RATE_LIMIT` 覆盖；`remote-config-url` 为远端配置地址，可用环境变量 `REMOTE_CONFIG_URL` 覆盖；**`api-keys` / `ws-keys` 为敏感凭据，不随远端配置覆盖**——`api-keys` 管 HTTP 转发鉴权，`ws-keys` 管 WS 注册校验，两者相互独立）。
 
 ## 方案二：二进制
 
@@ -37,7 +48,9 @@ CGO_ENABLED=0 GOOS=linux GOARCH=amd64 go build -o middleware-go-linux-amd64 .
 ./middleware-go-linux-amd64          # 运行（与 setting.json 同目录）
 ```
 
-所有配置可用环境变量覆盖（`API_BASE_URLS` / `IP_LOCATION_APIS` / `CORS` / `APIKEYS` / `RATE_LIMIT` 等，数组/对象用 JSON 字符串），优先级：**环境变量 > setting.json > 默认值**（远端配置 `REMOTE_CONFIG_URL` 高于两者，详见 [配置文件 - 远端配置](/guide/config#远端配置remoteconfigurl)）。
+**OTA 自更新**（可选，默认关闭）：配置 `"ota": "true"`（或环境变量 `OTA=true`）后，中间件定期检查本仓库 Release，下载与当前平台匹配的 `middleware-go-*` 资产并替换自身重启。下载加速可配 `"gh-proxy": ""`（或 `GH_PROXY` 环境变量）。交接流程与后端节点一致：预检 → 原子替换 → 优雅停机 → 拉起新进程 → 健康检查确认；失败自动回滚 `.old` 备份。
+
+所有配置可用环境变量覆盖（`API_BASE_URLS` / `IP_LOCATION_APIS` / `CORS` / `TRUSTED_PROXIES` / `API_KEYS` / `WS_KEYS` / `RATE_LIMIT` 等，数组/对象用 JSON 字符串），优先级：**环境变量 > setting.json > 默认值**（远端配置 `REMOTE_CONFIG_URL` 高于两者，详见 [配置文件 - 远端配置](/guide/config#远端配置remoteconfigurl)）。
 
 需要守护运行时，参考 [后端节点部署 - 方案五：一键安装](/guide/deploy-node#方案五一键安装installsh) 的 systemd 管理方式（`ExecStart` 指向中间件二进制，`WorkingDirectory` 指向 `middleware-go/setting.json` 所在目录）。
 
@@ -61,10 +74,11 @@ middleware-go 内置 WS 服务端，后端节点可作为 **WS 客户端**连入
 ```json
 {
     "port": "8091",
-    "apiBaseUrls": [
-        { "label": "上海 腾讯云 BGP", "id": "tencent-sh", "url": "", "ws": true }
-    ],
-    "TCPing": { "DualStack": [], "IPv4": [], "IPv6": [ { "label": "河北 秦皇岛 联通", "id": "cn-hebei-qinhuangdao", "url": "https://cn-hebei-qinhuangdao.api-ipw.wsmdn.top/", "ws": true } ] }
+    "APIBaseURL": {
+        "DualStack": [ { "label": "上海 腾讯云 BGP", "id": "tencent-sh", "url": "", "ws": true } ],
+        "IPv4": [],
+        "IPv6": [ { "label": "河北 秦皇岛 联通", "id": "cn-hebei-qinhuangdao", "url": "https://cn-hebei-qinhuangdao.api-ipw.wsmdn.top/", "ws": true } ]
+    }
 }
 ```
 
@@ -76,7 +90,7 @@ middleware-go 内置 WS 服务端，后端节点可作为 **WS 客户端**连入
 
 | 方向 | type | data 说明 |
 |------|------|-----------|
-| 节点 → middleware | `register` | `{ "nodeId": "...", "key": "..." }`，连接后首条消息，同 id 新连接顶掉旧连接；`key` 为注册凭证，与 setting.json `apiKeys` 配置比对 |
+| 节点 → middleware | `register` | `{ "nodeId": "...", "key": "..." }`，连接后首条消息，同 id 新连接顶掉旧连接；`key` 为注册凭证，与 setting.json `ws-keys` 配置比对 |
 | middleware → 节点 | `register_ok` | `{ "heartbeatSeconds": 20 }` |
 | middleware → 节点 | `register_error` | `{ "code": 401, "command": "invalid key" }`（注册凭证错误时返回并断开连接） |
 | middleware → 节点 | `probe` | `{ "requestId": "...", "apiType": "tcping", "raw": "qq.com", "query": {"port":"443"} }`，拨测请求（HTTP/WS 双通道时前端请求仍走 HTTP，middleware 内部转 WS） |
@@ -87,22 +101,22 @@ middleware-go 内置 WS 服务端，后端节点可作为 **WS 客户端**连入
 
 ### 节点侧接入（WS 客户端）
 
-1. 连接 `ws://<中间件IP>:8092/ws`（本仓库后端节点接入方式见 [后端节点部署 - WS 通道接入](/guide/deploy-node#ws-通道接入可选)，配置 `WS_URL` / `NODE_ID` / `NODE_KEY` 即可自动连接注册）
-2. 首条消息发 `register { "nodeId": "<与中间件配置一致的节点 id>", "key": "<注册凭证>" }`（节点在 setting.json `apiKeys` 里配了 key 就必须传对；未配置 key 的开放节点可不传）
+1. 连接 `ws://<中间件IP>:8092/ws`（本仓库后端节点接入方式见 [后端节点部署 - WS 通道接入](/guide/deploy-node#ws-通道接入可选)，配置 `WS_URL` / `NODE_ID` / `NODE_KEY` 即可自动连接注册；`WS_URL` 支持逗号分隔多个中间件地址，节点会**同时连接全部（多活）**，任一断开只重连自己）
+2. 首条消息发 `register { "nodeId": "<与中间件配置一致的节点 id>", "key": "<注册凭证>" }`（节点在 setting.json `ws-keys` 里配了 key 就必须传对；未配置 key 的开放节点可不传）
 3. 收到 `probe` → 执行拨测 → 回 `probe_result`（必须携带原 `requestId`，支持乱序返回，同一连接可并发多个拨测）
 4. 收到 `ping` → 回 `pong`；`status` 可忽略或记录
 5. 断线后重连并重新 `register` 即可
 
 ### 注册 key 校验
 
-节点注册时中间件按 `apiKeys` 配置校验 key：
+节点注册时中间件按 `ws-keys` 配置校验 key（与 `api-keys` HTTP 转发鉴权相互独立）：
 
-- 节点在 `apiKeys` 配置了 key（非空）→ `register` 必须携带正确 key，不传或传错返回 `register_error { "code": 401, "command": "invalid key" }` 并**断开连接**，不进入数据阶段
-- 节点未配置 key（`apiKeys` 无该项或为空）→ 开放注册，不传 key 即可
+- 节点在 `ws-keys` 配置了 key（非空）→ `register` 必须携带正确 key，不传或传错返回 `register_error { "code": 401, "command": "invalid key" }` 并**断开连接**，不进入数据阶段
+- 节点未配置 key（`ws-keys` 无该项或为空）→ 开放注册，不传 key 即可
 
 与 HTTP 通道的鉴权语义一致（配置了 key 就必须带凭据，留空 = 开放）。
 
 ### 说明
 
-- 注册阶段按节点 `apiKeys` 配置校验 key（配了 key 必须传对，否则 401 断开；未配置则开放，详见上文「注册 key 校验」）；拨测请求经 WS 转发时不携带 `Authorization` 头（后续由节点侧自行决定是否需要额外鉴权）
+- 注册阶段按节点 `ws-keys` 配置校验 key（配了 key 必须传对，否则 401 断开；未配置则开放，详见上文「注册 key 校验」）；拨测请求经 WS 转发时不携带 `Authorization` 头（后续由节点侧自行决定是否需要额外鉴权）
 - `ws:true` 且 WS 未启用（`WS_PORT=0`）时，自动回退原 HTTP 转发

docs/guide/deploy-node.md

@@ -4,62 +4,91 @@
 
 ## 方案一：EdgeOne
 
-腾讯云 EdgeOne 支持 Go 边缘函数，点击下方按钮通过 **EdgeOne Makers** 一键部署 `edgeone/` 版本（无需本地构建）：
+腾讯云 EdgeOne 支持 Go 边缘函数，点击下方按钮通过 **EdgeOne Makers** 一键部署 `serverless/edgeone/` 版本（无需本地构建）：
 
-[![使用 EdgeOne Makers 部署](https://cdnstatic.tencentcs.com/edgeone/pages/deploy.svg)](https://console.cloud.tencent.com/edgeone/makers/new?repository-url=https%3A%2F%2Fgithub.com%2Fnomdn%2Fipw-cn&root-directory=edgeone)
+[![使用 EdgeOne Makers 部署](https://cdnstatic.tencentcs.com/edgeone/pages/deploy.svg)](https://console.cloud.tencent.com/edgeone/makers/new?repository-url=https%3A%2F%2Fgithub.com%2Fnomdn%2Fipw-cn&root-directory=serverless%2Fedgeone)
 
 
 也可以使用 EdgeOne CLI 手动部署：
 
 ```bash
-cd edgeone
+cd serverless/edgeone
 npx edgeone pages deploy -n ipw-cn -t $EDGEONE_API_TOKEN
 ```
 
-`edgeone/` 版本的配置来源为 环境变量 + 远端配置（`REMOTE_CONFIG_URL`）。
+`serverless/edgeone/` 版本的配置来源为 环境变量 + 远端配置（`REMOTE_CONFIG_URL`）。
 
 ## 方案二：Vercel
 
-点击下方按钮一键导入仓库（部署目标为 `edgeone/cloud-functions` 目录，即 Go 边缘函数版本）：
+点击下方按钮一键导入仓库（部署目标为 `serverless/edgeone/cloud-functions` 目录，即 Go 边缘函数版本）：
 
-[![Deploy with Vercel](https://vercel.com/button)](https://vercel.com/new/clone?repository-url=https%3A%2F%2Fgithub.com%2Fnomdn%2Fipw-cn&root-directory=edgeone%2Fcloud-functions)
+[![Deploy with Vercel](https://vercel.com/button)](https://vercel.com/new/clone?repository-url=https%3A%2F%2Fgithub.com%2Fnomdn%2Fipw-cn&root-directory=serverless%2Fedgeone%2Fcloud-functions)
 
 > [!IMPORTANT]
 > **Serverless 节点均为 IPv4-only**（EdgeOne、Vercel 等平台的出站网络只提供 IPv4）。部署后需要：
 >
 > 1. 给节点配置 `SINGLE_STACK=ipv4`（声明节点为 IPv4 单栈），跳过 IPv6 相关测试，避免无意义的错误日志与超时
-> 2. 在前端配置 `config/index.ts` 中，**该节点只能填入 `TCPing.IPv4` / `SpeedTest.IPv4` 等 IPv4 分组**，不要放进 `DualStack` / `IPv6` 分组
+> 2. 在前端配置 `config/index.ts` 中，**该节点只能填入 `APIBaseURL.IPv4`**（拨测节点池的 IPv4 栈），不要放进 `DualStack` / `IPv6` 栈
 
 ## 方案三：Docker
 
-仓库根目录提供 `Dockerfile`（多阶段构建，产物基于 Alpine）：
+`src/` 目录提供 `Dockerfile`（多阶段构建，产物基于 Alpine，支持多架构）：
 
 ```bash
+cd src
 docker build -t lemon-ipw .
-docker run -d -p 8080:8080 \
-  -v $(pwd)/setting.json:/app/setting.json \
+docker run -d --restart unless-stopped -p 8080:8080 \
+  -v $(pwd)/setting.json:/home/appuser/setting.json \
   lemon-ipw
 ```
 
-配置通过挂载 `setting.json` 提供，也可用环境变量覆盖（`PORTS` / `CORS` / `ACCESS_TOKEN` 等）。
+> `--restart unless-stopped`：主进程退出时 Docker 自动拉起容器（OTA 更新失败自愈依赖它）；手动 `docker stop` 不会触发重启。
+
+配置通过挂载 `setting.json` 提供（注意挂载到容器工作目录 `/home/appuser`），也可用环境变量覆盖（`PORTS` / `CORS` / `TRUSTED_PROXIES` / `ACCESS_TOKEN` 等）。
+
+**多架构**：Dockerfile 已适配 buildx——构建阶段固定在构建机原生平台交叉编译（`TARGETOS`/`TARGETARCH`），目标架构无需 QEMU 模拟。本机为其他架构构建：
+
+```bash
+cd src
+docker buildx build --platform linux/arm64 -t lemon-ipw:arm64 --load .
+```
+
+打 `v*` 版本标签发版时，CI（`.github/workflows/docker.yml`）会自动构建 `linux/amd64` / `linux/arm64` / `linux/arm/v7` 三架构镜像（amd64 在 x64 实例上原生构建，arm64/armv7 在 GitHub 原生 ARM 实例 `ubuntu-24.04-arm` 上交叉构建，全程无 QEMU），推送 GHCR 与 Docker Hub：
+
+- GHCR：`ghcr.io/<owner>/<repo>/lemon-ipw`（自动）
+- Docker Hub：`docker.io/<namespace>/lemon-ipw`（**workflow 中暂未启用**——`.github/workflows/docker.yml` 已预留注释，取消注释并配置 `DOCKERHUB_USERNAME` / `DOCKERHUB_TOKEN` Secrets 即可开启）
+
+均带 `版本` 与 `major.minor` 标签。部署直接：
+
+```bash
+docker run -d -p 8080:8080 \
+  -v $(pwd)/setting.json:/home/appuser/setting.json \
+  ghcr.io/nomdn/ipw-cn/lemon-ipw:v1.2.3
+```
+
+Docker 会按宿主机架构自动拉取 manifest 中对应的镜像变体。
 
 ## 方案四：二进制
 
 ```bash
-# 编译
-go build -o lemonipw main.go
+# 编译（Go 后端在 src/ 目录）
+cd src && go build -o lemonipw .
 
 # 运行（与 setting.json 同目录）
 ./lemonipw
 ```
 
-首次启动自动下载 IP 数据库（约 200MB），之后每 24 小时自动更新一次。需要守护运行时，可参考下方「方案五」生成的 systemd 服务，或手动创建 service 文件（`ExecStart` 指向二进制，`WorkingDirectory` 指向 `setting.json` 所在目录）。
+首次启动自动下载 IP 数据库（约 450MB），之后每 24 小时自动更新一次。需要守护运行时，可参考下方「方案五」生成的 systemd 服务，或手动创建 service 文件（`ExecStart` 指向二进制，`WorkingDirectory` 指向 `setting.json` 所在目录）。
 
 ## 方案五：一键安装（install.sh）
 
 仓库根目录提供 `install.sh` 一键安装脚本：自动检测架构 → 下载最新 release 二进制 → **交互式输入配置**（无需准备 setting.json，配置以环境变量注入）→ 生成 systemd 服务并守护进程。
 
 ```bash
+# 先下载脚本到本地（勿用 curl | bash 管道执行，避免下载中断导致语法解析错误）
+git clone https://github.com/nomdn/ipw-cn && cd ipw-cn   # 或
+curl -fsSL https://raw.githubusercontent.com/nomdn/ipw-cn/main/install.sh -o install.sh
+
 sudo bash install.sh
 ```
 
@@ -69,20 +98,21 @@ sudo bash install.sh
 |--------|--------|------|
 | 安装目录 | `/opt/lemon-ipw` | 二进制与工作目录 |
 | 监听端口 | `8080` | `PORTS` |
-| access_token | 留空 | 留空 = 不启用鉴权 |
-| DNS 服务器 | `119.28.28.28:53` | 主从逗号分隔（`119.28.28.28:53,223.5.5.5:53`） |
-| DNSSEC 专用 DNS | 留空 | 留空 = 沿用 dns-server |
-| IP 数据库 | `Y` | `IPDB`，首次启动下载约 200MB |
+| 单栈模式 | 双栈 | `SINGLE_STACK`，`ipv4` / `ipv6` / 留空 |
+| access-token | 留空 | 留空 = 不启用鉴权 |
+| DNS 服务器 | 留空 | 主从逗号分隔（`119.28.28.28:53,223.5.5.5:53`）；留空 = 启动时自动探测系统 DNS |
+| DNSSEC 专用 DNS | 留空 | 留空 = 沿用 dns-server；都留空 = 自动探测系统 DNS |
+| IP 数据库 | `Y` | `IPDB`，首次启动下载约 450MB |
 | CORS | 留空 | 逗号分隔允许来源 |
 | 远端配置地址 | 留空 | `REMOTE_CONFIG_URL` |
 | WS 通道接入 | `N` | 选 `y` 后继续输入 WS_URL / NODE_ID / NODE_KEY |
-| 其他环境变量 | 无 | 每行一个 `K=V`，空行结束 |
+| 其他环境变量 | 无 | 每行一个 `K=V`，空行结束。如需可信代理在此输入 `TRUSTED_PROXIES=<IP/CIDR 逗号分隔>`（配置后归属地接口只信任这些代理转发的 X-Forwarded-For，防伪造） |
 
 **WS 接入特殊规则**：
 
-- `WS_URL` 留空时自动使用默认值 `wss://middleware-1.api-ipw.wsmdn.top/ws`；填写自己的中间件地址时须为**完整路径**（含 `wss://` 前缀与 `/ws` 路径，如 `wss://host:8092/ws`），逗号分隔多备
+- `WS_URL` 留空时自动使用默认值 `wss://middleware-1.api-ipw.wsmdn.top/ws`；填写自己的中间件地址时须为**完整路径**（含 `wss://` 前缀与 `/ws` 路径，如 `wss://host:8092/ws`），逗号分隔多个则**同时连接全部（多活）**
 - `NODE_ID` **强制自动生成 UUID**（无需输入，如 `4580ea9d-2a16-4b8e-8090-5f2e7f0a2229`），适合作为节点唯一标识
-- `NODE_KEY` **必填**：不加 key 禁止启用 WS（中间件 `apiKeys` 必须包含该节点，否则注册被拒 401）；安装完成后脚本会提示把 `"<NODE_ID>": "<NODE_KEY>"` 加入中间件 setting.json 的 `apiKeys`
+- `NODE_KEY` **必填**：不加 key 禁止启用 WS（中间件 `ws-keys` 必须包含该节点，否则注册被拒 401）；安装完成后脚本会提示把 `"<NODE_ID>": "<NODE_KEY>"` 加入中间件 setting.json 的 `ws-keys`
 
 **安装完成后自动生成并启动 systemd 服务**（`lemon-ipw.service`），配置以 `Environment="K=V"` 注入，无需 setting.json。常用管理命令：
 
@@ -94,6 +124,7 @@ sudo systemctl restart lemon-ipw  # 重启（改配置后）
 
 修改配置：`sudo systemctl edit --full lemon-ipw` 编辑环境变量，保存后 `sudo systemctl daemon-reload && sudo systemctl restart lemon-ipw` 生效。
 
+> [!WARNING]
 > **版本兼容提醒**：v1.1.0 及更早的 release 二进制读的是旧环境变量名 `IPW_WS_URL` / `IPW_NODE_ID` / `IPW_NODE_KEY`（8-20 及之前构建）。install.sh 生成的 service 用的是新名 `WS_URL` / `NODE_ID` / `NODE_KEY`——**旧二进制 + 新 service 会因读不到配置而完全不启用 WS**（启动日志无任何 ws 输出）。升级到包含改名后的新 release 即可；急用可临时把 service 环境变量改回 `IPW_` 前缀。
 
 ## 配置
@@ -104,18 +135,38 @@ sudo systemctl restart lemon-ipw  # 重启（改配置后）
 
 后端节点可作为 WS 客户端接入 [独立中间件](/guide/deploy-middleware) 的 WS 通道，拨测请求经 WebSocket 转发，节点本地执行探针后回传。不配置则完全走原 HTTP 接口。
 
-**配置三个环境变量**（或 setting.json 的 `ws-url` / `node-id` / `node-key`，env 优先；也支持远端配置覆盖，除非列入 `remote-ingore-config`）：
+**配置三个环境变量**（或 setting.json 的 `ws-url` / `node-id` / `node-key`，env 优先；也支持远端配置覆盖，除非列入 `remote-ignore-config`）：
 
 ```bash
 WS_URL=ws://<中间件IP>:8092/ws \
-NODE_ID=<节点id，与中间件 apiBaseUrls 的节点 id 一致> \
-NODE_KEY=<注册key，与中间件 apiKeys[节点id] 一致；节点未配置 key 可留空> \
+NODE_ID=<节点id，与中间件 api-base-url / ip-location-api 池的节点 id 一致> \
+NODE_KEY=<注册key，与中间件 ws-keys[节点id] 一致；节点未配置 key 可留空> \
 ./lemonipw
 ```
 
-- `WS_URL` 支持**逗号分隔多个中间件**（`ws://主:8092/ws,ws://备:8092/ws`），第一个为主，主故障自动切换下一个
+- `WS_URL` 支持**逗号分隔多个中间件**（`ws://中间件1:8092/ws,ws://中间件2:8092/ws`），**同时连接全部（多活）**：每个地址独立注册并保持连接，任一断开只重连自己，不影响其他中间件；注意多个地址指向同一中间件实例时，同 `nodeId` 后注册的连接会顶掉先前的
 - **双向心跳**：节点每 10s 发 ping，中间件回 pong；心跳发送连续失败 3 次判定中间件不可用，断开后 3s 重试（注册被拒 30s 重试）
 - 收到 `probe` 后节点直调探针函数（带缓存）并回 `probe_result`，结果与 HTTP 通道一致
-- 节点注册带 `NODE_KEY`：中间件 `apiKeys` 里配了 key 就必须传对，否则返回 401 并断开；未配置 key 的节点开放注册
+- 节点注册带 `NODE_KEY`：中间件 `ws-keys` 里配了 key 就必须传对，否则返回 401 并断开；未配置 key 的节点开放注册
 
-**注意**：`NODE_ID` 必须与中间件 `apiBaseUrls` / `TCPing` / `SpeedTest` 等配置中的节点 `id` 一致，且该节点需配置 `"ws": true` 才会走 WS 通道。未连接中间件时，`ws:true` 节点的拨测会返回 502。
+**注意**：`NODE_ID` 必须与中间件 `APIBaseURL` / `IPLocationAPI` 池中的节点 `id` 一致，且该节点需配置 `"ws": true` 才会走 WS 通道。未连接中间件时，`ws:true` 节点的拨测会返回 502。
+
+## OTA 自更新（可选）
+
+节点支持**自动升级**：检测到本仓库有新 Release 时，下载对应平台的二进制、**替换自身并重启**。
+
+```bash
+# 启用（环境变量，或 setting.json 的 "node-ota": "true"）
+NODE_OTA=true ./lemonipw
+```
+
+- **默认关闭**，需显式开启；远端配置（`node-ota`）也可统一开关，除非列入 `remote-ignore-config`
+- **检查时机**：启动 5 分钟后首次检查，之后每 6 小时 + 随机 0~1h 抖动
+- **major 变化不自动更新**：仅 minor/patch 升级自动跟进（如 3.1.0 → 3.2.0）；主版本变化（如 3.x → 4.x，通常含破坏性变更）会跳过并告警，需人工升级
+- **更新流程**：查询 GitHub 最新 Release → 按 `GOOS/GOARCH` 匹配资产（如 `lemonipw-linux-amd64`、`lemonipw-windows-amd64.exe`）→ 下载到同目录临时文件（经 `gh-proxy` 前缀加速，文件过小则丢弃）→ 当前二进制改名备份为 `<程序名>.old` → 新二进制就位 → 重启
+- **重启方式**：Linux/macOS 用 `exec` 原地替换进程镜像（PID 不变，systemd / Docker 无感）；Windows 另起新进程后退出当前进程
+- **失败处理**：下载/替换失败仅记录日志并继续运行，下次周期重试；替换过程中断会自动回滚到 `.old`
+- **注意事项**：
+  - 二进制所在目录需**可写**（Docker 只读层或只读挂载会导致替换失败）
+  - 建议保留 `.old` 备份以便手动回滚：`mv lemonipw.old lemonipw`
+  - systemd 部署时若 OTA 重启未被托管，可配 `Restart=always` 兜底

docs/guide/getting-started.md

@@ -20,12 +20,15 @@
 ```bash
 # 获取安装脚本（任选其一）
 git clone https://github.com/nomdn/ipw-cn && cd ipw-cn   # 或
-curl -LO https://raw.githubusercontent.com/nomdn/ipw-cn/main/install.sh
+curl -fsSL https://raw.githubusercontent.com/nomdn/ipw-cn/main/install.sh -o install.sh
 
 # 执行安装（root 权限）
 sudo bash install.sh
 ```
 
+> [!WARNING]
+> 请勿使用 `curl ... | sudo bash` 管道方式执行：脚本经管道边下载边执行，网络慢/抖动时 bash 会读到不完整的脚本内容，报 `syntax error near unexpected token` 类错误（脚本本身无语法问题）。务必**先下载完整文件再执行**。
+
 脚本会自动完成：检测架构 → 下载最新 release 二进制 → **交互式输入配置** → 生成并启动 systemd 守护进程。
 
 **交互式配置项**（直接回车使用默认值）：
@@ -34,20 +37,21 @@ sudo bash install.sh
 |--------|--------|------|
 | 安装目录 | `/opt/lemon-ipw` | 二进制与工作目录 |
 | 监听端口 | `8080` | 后端 HTTP 端口 |
-| access_token | 留空 | 留空 = 不启用鉴权 |
-| DNS 服务器 | `119.28.28.28:53` | 主从逗号分隔（如 `119.28.28.28:53,223.5.5.5:53`） |
-| DNSSEC 专用 DNS | 留空 | 留空 = 沿用 dns-server |
-| IP 数据库 | `Y` | 首次启动下载约 200MB |
+| 单栈模式 | 双栈 | `SINGLE_STACK`，`ipv4` / `ipv6` / 留空 |
+| access-token | 留空 | 留空 = 不启用鉴权 |
+| DNS 服务器 | 留空 | 主从逗号分隔（如 `119.28.28.28:53,223.5.5.5:53`）；留空 = 启动时自动探测系统 DNS |
+| DNSSEC 专用 DNS | 留空 | 留空 = 沿用 dns-server；都留空 = 自动探测系统 DNS |
+| IP 数据库 | `Y` | 首次启动下载约 450MB |
 | CORS | 留空 | 逗号分隔允许来源 |
 | 远端配置地址 | 留空 | `REMOTE_CONFIG_URL` |
 | WS 通道接入 | `N` | 选 `y` 后输入 WS_URL / NODE_ID / NODE_KEY |
-| 其他环境变量 | 无 | 每行一个 `K=V`，空行结束 |
+| 其他环境变量 | 无 | 每行一个 `K=V`，空行结束。如需可信代理在此输入 `TRUSTED_PROXIES=<IP/CIDR 逗号分隔>`（配置后归属地接口只信任这些代理转发的 X-Forwarded-For，防伪造） |
 
 **WS 通道接入规则**（选 `y` 时）：
 
-- `WS_URL` 留空自动使用默认值 `wss://middleware-1.api-ipw.wsmdn.top/ws`；填写自己的中间件地址须为完整路径（`wss://host:8092/ws` 形式）
+- `WS_URL` 留空自动使用默认值 `wss://middleware-1.api-ipw.wsmdn.top/ws`；填写自己的中间件地址须为完整路径（`wss://host:8092/ws` 形式）；逗号分隔多个则**同时连接全部（多活）**
 - `NODE_ID` **强制自动生成 UUID**（无需输入）
-- `NODE_KEY` **必填**：不加 key 禁止启用 WS；安装完成后脚本会提示把 `"<NODE_ID>": "<NODE_KEY>"` 加入中间件 `apiKeys`
+- `NODE_KEY` **必填**：不加 key 禁止启用 WS；安装完成后脚本会提示把 `"<NODE_ID>": "<NODE_KEY>"` 加入中间件 `ws-keys`
 
 ### 验证安装
 

docs/guide/index.md

@@ -23,5 +23,5 @@ Lemon IPW 采用前后端分离架构，**后端节点、独立中间件、前
 | 工作流 | 部署目标 |
 |--------|----------|
 | `frontend-ssr.yml` | SSR 前端 → Cloudflare Workers |
-| `edgeone-backend.yml` | `edgeone/` → EdgeOne Pages |
+| `edgeone-backend.yml` | `serverless/edgeone/` → EdgeOne Pages |
 | `build_and_release.yml` | 后端多平台构建与发布（Release 附带配置文件） |

frontend-ssr/app/pages/asn.vue

@@ -10,10 +10,10 @@ const route = useRoute()
 useHead({
   title: `ASN查询 | IP自治系统号查询 | ${config.siteName}`,
   meta: [
-    { name: 'description', content: '专业的ASN自治系统查询工具,支持IP地址ASN号查询,提供Maxmind GEOLite2、DB-IP双数据源对比,同时集成WHOIS解析获取ASN详细信息,包括组织名称、国家、注册日期等,助力网络运维和路由分析' },
+    { name: 'description', content: '专业的ASN自治系统查询工具,支持IP地址ASN号查询,提供Maxmind GEOLite2、DB-IP、IP2Location 多数据源对比,同时集成WHOIS解析获取ASN详细信息,包括组织名称、国家、注册日期等,助力网络运维和路由分析' },
     { name: 'keywords', content: 'asn查询,自治系统号,asn lookup,ip asn,asn whois,网络自治系统,运营商asn,ip归属asn' },
     { property: 'og:title', content: 'ASN自治系统查询工具 - IP ASN号与组织信息查询' },
-    { property: 'og:description', content: '多数据源ASN查询,支持Maxmind GEOLite2和DB-IP,集成WHOIS解析获取ASN详细信息' },
+    { property: 'og:description', content: '多数据源ASN查询,支持Maxmind GEOLite2、DB-IP、IP2Location，集成WHOIS解析获取ASN详细信息' },
     { property: 'og:image', content: config.siteUrl + 'favicon.svg' },
     { property: 'og:type', content: 'website' },
   ],
@@ -24,7 +24,7 @@ useHead({
         '@context': 'https://schema.org',
         '@type': 'WebApplication',
         name: 'ASN自治系统查询工具',
-        description: '专业的ASN自治系统查询工具，支持IP地址ASN号查询，提供Maxmind GEOLite2、DB-IP双数据源对比，集成WHOIS解析。',
+        description: '专业的ASN自治系统查询工具，支持IP地址ASN号查询，提供Maxmind GEOLite2、DB-IP、IP2Location 多数据源对比，集成WHOIS解析。',
         url: config.siteUrl + 'asn',
         applicationCategory: 'DeveloperApplication',
         operatingSystem: 'Web',
@@ -46,6 +46,7 @@ interface ASNResult {
   ip: string
   geolite2_asn?: { asn: string; org: string }
   dbip_asn?: { asn: string; org: string }
+  ip2location_asn?: { asn: string; as: string }
   whois?: any
 }
 
@@ -55,12 +56,12 @@ const result = ref<ASNResult | null>(null)
 const error = ref('')
 const userIP = ref('')
 
-const apiList = config.IPLocationAPIs
+const apiList = config.IPLocationAPI
 const currentApiIndex = ref(0)
 const backendID = computed(() => apiList[currentApiIndex.value]?.id || '')
 
 
-const { data: asnData, error: asnError, execute: executeASN } = useMiddlewareFetch<ASNResult>(() => '/middleware/' + backendID.value + '/asn/' + tmpIP.value, {
+const { data: asnData, error: asnError, execute: executeASN } = useMiddlewareFetch<ASNResult>(() => '/middleware/' + backendID.value + '/asn/' + encodeURIComponent(tmpIP.value), {
   key: 'asn-fetch',
   immediate: false,
   watch: false,
@@ -118,11 +119,11 @@ onMounted(() => {
 })
 
 async function getUserIP() {
-  await $fetch<string>(config.DualStackAPI).then(
-    function (data) {
-      userIP.value = data
-    }
-  )
+  try {
+    userIP.value = await $fetch<string>(config.DualStackAPI)
+  } catch {
+    // 获取失败保持为空，避免未处理的 Promise 拒绝
+  }
   return userIP.value
 }
 
@@ -185,6 +186,13 @@ function getStatusClass(status: string): string {
               <span v-if="result.dbip_asn.org" style="color: #999; font-size: 0.9em;">{{ result.dbip_asn.org }}</span>
             </td>
           </tr>
+          <tr v-if="result.ip2location_asn?.asn">
+            <td class="table-label">IP2Location ASN</td>
+            <td class="table-value">
+              AS{{ result.ip2location_asn.asn }}
+              <span v-if="result.ip2location_asn.as" style="color: #999; font-size: 0.9em;">{{ result.ip2location_asn.as }}</span>
+            </td>
+          </tr>
           <tr v-if="result.whois?.asNumber">
             <td class="table-label">ASN</td>
             <td class="table-value">AS{{ result.whois.asNumber }}</td>
@@ -226,7 +234,6 @@ function getStatusClass(status: string): string {
     </div>
 
     <blockquote>
-      <a href="/doc/user/asn" target="_blank">ASN 查询原理介绍</a><br/>
       ASN（Autonomous System Number）是互联网中每个自治系统的唯一标识符。<br/>
       数据来源：Maxmind GEOLite2、DB-IP，部分节点集成 WHOIS 进一步解析 ASN 详情。<br/>
       <a href="/location" target="_blank">IP 归属地查询</a> | <a href="/whois" target="_blank">Whois 查询</a><br/>

frontend-ssr/app/pages/dns.vue

@@ -50,13 +50,15 @@ const results = ref<any>([])
 const isloading = ref(false)
 const nowRecordType = ref('')
 const userIP = ref('')
+// 查询序号：连续点击时旧查询的结果不允许写入新查询的结果表
+let queryId = 0
 
 async function getUserIP(){
-  
-  await $fetch<string>(config.DualStackAPI).then(
-  function (data){
-    userIP.value = data
-  })
+  try {
+    userIP.value = await $fetch<string>(config.DualStackAPI)
+  } catch {
+    // 获取失败保持为空，避免未处理的 Promise 拒绝
+  }
   return userIP.value
 }
 
@@ -72,8 +74,12 @@ const recordTypes = [
   { value: 'ptr', label: 'PTR 记录' }
 ]
 
-const dnsServerFetches = config.NSLookup.map((server) => {
-  const url = computed(() => "/middleware/" + server.id + "/dns/" + recordType.value + "/" + domain.value);
+const dnsServerFetches = [
+  ...config.APIBaseURL.DualStack,
+  ...config.APIBaseURL.IPv4,
+  ...config.APIBaseURL.IPv6
+].map((server) => {
+  const url = computed(() => "/middleware/" + server.id + "/dns/" + recordType.value + "/" + encodeURIComponent(domain.value));
   const { data, error, execute } = useMiddlewareFetch(url, {
     immediate: false,
     watch: false,
@@ -85,7 +91,9 @@ async function queryDNS() {
   isloading.value = true
   domain.value = tmpDomain.value
   await nextTick()
-  
+
+  const id = ++queryId
+
   // 初始化结果数组，保持响应式结构
   results.value = dnsServerFetches.map(fetch => ({
     server: fetch.label,
@@ -97,7 +105,20 @@ async function queryDNS() {
   const promises = dnsServerFetches.map(async (fetch, index) => {
     try {
       await fetch.execute();
-      
+
+      if (id !== queryId) return null
+
+      // execute() 不会抛错，全部候选失败时以 error.value 为准（否则故障节点渲染成空白）
+      if (fetch.error.value) {
+        results.value[index] = {
+          server: fetch.label,
+          loading: false,
+          data: null,
+          error: fetch.error.value
+        };
+        return { server: fetch.label, error: fetch.error.value };
+      }
+
       //  直接更新对应索引的结果，保持响应式
       results.value[index] = {
         server: fetch.label,
@@ -105,12 +126,13 @@ async function queryDNS() {
         data: fetch.data.value,
         error: null
       };
-      
+
       return {
         server: fetch.label,
         data: fetch.data.value
       };
     } catch (err) {
+      if (id !== queryId) return null
       //  错误时也更新对应索引
       results.value[index] = {
         server: fetch.label,
@@ -118,7 +140,7 @@ async function queryDNS() {
         data: null,
         error: err
       };
-      
+
       return {
         server: fetch.label,
         error: err
@@ -126,10 +148,11 @@ async function queryDNS() {
     }
   });
   nowRecordType.value = recordType.value
-  const promiseResults = await Promise.all(promises)
-  console.log(promiseResults)
-  isloading.value = false
-  
+  const promiseResults = (await Promise.all(promises)).filter(Boolean)
+  if (id === queryId) {
+    isloading.value = false
+  }
+
   return promiseResults
 }
 

frontend-ssr/app/pages/dnssec.vue

@@ -68,11 +68,17 @@ const tmpDomain = ref('www.zakoflare.com')
 const loading = ref(false)
 const serverResults = ref<ServerResult[]>([])
 const userIP = ref('')
+// 查询序号：连续点击时旧查询的结果不允许写入新查询的结果表
+let queryId = 0
 
-const apiList = config.NSLookup
+const apiList = [
+  ...config.APIBaseURL.DualStack,
+  ...config.APIBaseURL.IPv4,
+  ...config.APIBaseURL.IPv6
+]
 
 const dnssecFetches = apiList.map((server) => {
-  const url = computed(() => "/middleware/" + server.id + "/dnssec/" + tmpDomain.value)
+  const url = computed(() => "/middleware/" + server.id + "/dnssec/" + encodeURIComponent(tmpDomain.value.trim()))
   const { data, error, execute } = useMiddlewareFetch<DNSSECResult>(url, {
     immediate: false,
     watch: false,
@@ -93,6 +99,8 @@ async function checkDNSSEC() {
 
   loading.value = true
 
+  const id = ++queryId
+
   serverResults.value.forEach((result) => {
     result.loading = true
     result.data = undefined
@@ -101,9 +109,15 @@ async function checkDNSSEC() {
   const promises = dnssecFetches.map(async (fetch, index) => {
     try {
       await fetch.execute()
+      if (id !== queryId) return
       const result = serverResults.value[index]
       if (result) {
-        result.data = fetch.data.value
+        // execute() 不会抛错，失败以 error.value 为准（否则故障节点渲染成 '-'）
+        if (fetch.error.value) {
+          result.error = (fetch.error.value as any)?.message || '请求失败'
+        } else {
+          result.data = fetch.data.value
+        }
       }
     } catch (err) {
       console.error(err)
@@ -113,14 +127,16 @@ async function checkDNSSEC() {
       }
     } finally {
       const result = serverResults.value[index]
-      if (result) {
+      if (result && id === queryId) {
         result.loading = false
       }
     }
   })
 
   Promise.allSettled(promises).finally(function () {
-    loading.value = false
+    if (id === queryId) {
+      loading.value = false
+    }
   })
 }
 
@@ -130,8 +146,8 @@ function getValidationClass(result: DNSSECResult): string {
   return 'status-error'
 }
 
-function formatDuration(ms: number): string {
-  return ms.toFixed(2) + ' ms'
+function formatDuration(ms?: number): string {
+  return typeof ms === 'number' && isFinite(ms) ? ms.toFixed(2) + ' ms' : '-'
 }
 
 onMounted(() => {
@@ -145,11 +161,11 @@ onMounted(() => {
 })
 
 async function getUserIP() {
-  await $fetch<string>(config.DualStackAPI).then(
-    function (data) {
-      userIP.value = data
-    }
-  )
+  try {
+    userIP.value = await $fetch<string>(config.DualStackAPI)
+  } catch {
+    // 获取失败保持为空，避免未处理的 Promise 拒绝
+  }
   return userIP.value
 }
 </script>
@@ -240,7 +256,7 @@ async function getUserIP() {
     </div>
 
     <blockquote>
-      <a href="/doc/user/dnssec" target="_blank">DNSSEC 原理介绍</a><br/>
+      DNSSEC 原理介绍即将上线<br/>
       DNSSEC 通过 DNSKEY、RRSIG、DS 记录为 DNS 数据提供完整性验证，防止 DNS 欺骗攻击。<br/>
       如果显示 "验证失败"，可能原因：域名未配置 DNSSEC、DNSKEY 密钥不匹配、DS 记录缺失等。<br/>
       <a href="/dns" target="_blank">DNS 解析查询</a> | <a href="/whois" target="_blank">Whois 查询</a><br/>

frontend-ssr/app/pages/doc/[...slug].vue

@@ -129,5 +129,5 @@ html.dark .content {
 </style>
 <style>
 @import "github-markdown-css/github-markdown-light.css";
-@import "/github-markdown-dark.css";
+@import "../../github-markdown-dark.css";
 </style>

frontend-ssr/app/pages/doc/index.vue

@@ -128,7 +128,7 @@ html.dark .content {
 </style>
 <style>
 @import "github-markdown-css/github-markdown-light.css";
-@import "/github-markdown-dark.css";
+@import "../../github-markdown-dark.css";
 @import "/style.css"
 
 </style>

frontend-ssr/app/pages/index.vue

@@ -122,8 +122,8 @@ onMounted(async () => {
       <b>IPv6</b>&nbsp<p v-if="yourIPv6">{{ yourIPv6 }}</p><RouterLink :to="`/location?ip=${yourIPv6}`" target="_blank" v-if="yourIPv6">&nbsp查询归属地</RouterLink><RouterLink v-else to="/doc/user/enable_ipv6" target="_blank">没有IPv6地址,查看如何开启IPv6</RouterLink>
     </div>
     <div style="font-size: 1.5em;">
-      <h3 v-if="(ipAddress && isIPv6(ipAddress)) || isIPv6(yourIPv6)"><el-icon><CircleCheckFilled style="color: lightgreen;"/></el-icon>您的网络IPv6优先</h3>
-      <h3 v-else-if="(ipAddress && isIPv4(ipAddress)) || isIPv6(yourIPv6)"><el-icon><CircleCloseFilled style="color: red;"/></el-icon>您的网络IPv4优先</h3>
+      <h3 v-if="ipAddress && isIPv6(ipAddress)"><el-icon><CircleCheckFilled style="color: lightgreen;"/></el-icon>您的网络IPv6优先</h3>
+      <h3 v-else-if="ipAddress && isIPv4(ipAddress)"><el-icon><CircleCloseFilled style="color: red;"/></el-icon>您的网络IPv4优先</h3>
       <h3 v-else><el-icon><CircleCloseFilled /></el-icon>查询中，请稍后</h3>
     </div>
      <blockquote>

frontend-ssr/app/pages/ipv6.vue

@@ -1,396 +1,26 @@
 <script setup lang="ts">
-import { ref, onMounted, computed, nextTick, watch } from 'vue';
-import { isIPv6 } from 'is-ip';
-import {config} from '../../config/index';
-import { useMiddlewareFetch } from '../../utils/middleware';
-import { CircleCheckFilled, CircleCloseFilled } from '@element-plus/icons-vue';
-import { useRoute } from 'vue-router'
-import { highlightCode } from '../../utils/shiki'
-import { isIPv4 } from '../../utils/tools';
+import { onMounted } from 'vue';
+import { useRoute } from 'vue-router';
+
 const route = useRoute();
-const loading = ref(false);
-
-useHead({
-  title: `IPv6/IPv4地址查询工具 | IP归属地定位 | ${config.siteName}`,
-  meta: [
-    { name: 'description', content: '专业的IPv6/IPv4地址查询工具,支持IPv4和IPv6地址归属地查询,提供BiliBili Live、GeoCN、IP2Region、Maxmind等多种数据源对比,精确定位IP地理位置、运营商信息,支持中国大陆及境外地址查询,助力IPv6普及与应用' },
-    { property: 'og:title', content: `IPv6/IPv4地址归属地查询工具 - ${config.siteName}` },
-    { property: 'og:description', content: '多数据源IP地址归属地查询,支持IPv4和IPv6,提供地理位置、运营商等详细信息' },
-    { property: 'og:image', content: config.siteUrl + 'favicon.svg' },
-    { property: 'og:type', content: 'website' },
-  ],
-});
-interface IPLocationType {
-  bilibili?: any;
-  ip?: string;
-  geocn?: any;
-  ip2region?: any;
-  maxmind_asn?: any;
-  maxmind_city?: any;
-  qqwry?: any;
-  [key: string]: any;
-}
-const code = `
-# 请勿用于商业用途，仅供个人测试学习之用，请遵守中国法律法规
-# 查询本机外网 IPv4 地址
-curl ${config.v4OnlyAPI}
-
-# 查询本机外网 IPv6 地址
-curl ${config.v6OnlyAPI}
-
-# 测试网络是 IPv4 还是 IPv6 访问优先 
-# (访问 IPv4/IPv6 双栈站点，如果返回 IPv6 地址，则 IPv6 访问优先)
-curl ${config.DualStackAPI}
-`.trim();
-const html = ref('');
-const apiList = config.IPLocationAPIs
-const currentApiIndex = ref(0)
-const backendID = computed(() => apiList[currentApiIndex.value]!.id)
-const ipAddress = ref('');
-const IPLocation = ref<IPLocationType>({});
-const UserIP = ref('');
-const locationUrl = computed(() => "/middleware/" + backendID.value + "/location/" + ipAddress.value);
-
-const { data: locationData, error: locationError, execute: executeLocation } = useMiddlewareFetch<IPLocationType>(locationUrl, {
-  immediate: false,
-  watch: false,
-});
-
-watch(locationData, (newData) => {
-  if (newData) {
-    IPLocation.value = newData;
-    loading.value = false;
-  }
-});
-
-watch(locationError, (newError) => {
-  if (newError) {
-    console.error('Error fetching IP location:', newError);
-    loading.value = false;
-  }
-});
-
-function locateIP(IP: string){
-  ipAddress.value = IP;
-  loading.value = true;
-  nextTick(() => {
-    executeLocation();
-  });
-}
 
 onMounted(async () => {
-
   const urlParam = route.query.ip;
-  await navigateTo({ path: '/location', query: { ip: urlParam } });
-  html.value = await highlightCode(code, 'bash')
-  if (urlParam) {
-    ipAddress.value = urlParam as string;
-    locateIP(urlParam as string);
-  }else{
-    $fetch<string>(config.DualStackAPI).then(
-      function(data) {
-        ipAddress.value = data;
-
-        UserIP.value = data;
-      }
-    ).catch(
-      function(error) {
-        console.error('Error fetching IP address:', error);
-      }
-    );
-
-  }
+  // ip 参数缺失时不要拼出 ?ip=undefined
+  await navigateTo(urlParam ? { path: '/location', query: { ip: urlParam } } : { path: '/location' });
 });
 </script>
+
 <template>
-  <div class="title">
-    <header>
-      <h1>IPv6/IPv4地址归属地查询</h1>
-      <p>极简的IPv6地址查询工具，致力于普及 IPv6</p>
-    </header>
-  </div>
-  <div class="content">
-    <div class="one-line">
-      <el-input 
-        v-model="ipAddress" 
-        placeholder="请输入IP地址" 
-      />
-      <el-button 
-        @click="locateIP(ipAddress)" 
-        type="primary" 
-        :loading="loading"
-      
-      >
-        查询
-      </el-button>
-    </div>
-    <div class="location">
-      <div class="one-line" style="height: 40px;">
-        <b>IP</b>&nbsp<p>{{ ipAddress }}</p>
-      </div>
-      <div v-if="IPLocation" class="result-section">
-          <table class="result-table">
-            <tbody>
-              <tr v-if="IPLocation.bilibili && (IPLocation.bilibili.administrative_area || IPLocation.bilibili.city)">
-                <td class="table-label">bilibili Live接口</td>
-                <td class="table-value">
-                  <span>
-                    {{ IPLocation.bilibili?.country }}&nbsp;{{ IPLocation.bilibili?.administrative_area }}&nbsp;{{ IPLocation.bilibili?.city }}
-                  </span>
-                </td>
-                <td class="table-value">
-                  <span>
-                    {{ IPLocation.bilibili?.isp }}
-                  </span>
-                </td>
-              </tr>
-              <tr v-if="IPLocation.ip2region && IPLocation.ip2region.split('|').length >= 4">
-                <td class="table-label">IP2Region</td>
-                <td class="table-value">{{ IPLocation.ip2region?.split("|")[0] }}&nbsp;{{ IPLocation.ip2region?.split("|")[1] }}&nbsp;{{ IPLocation.ip2region?.split("|")[2] }}</td>
-                <td class="table-value">{{ IPLocation.ip2region?.split("|")[3] }}</td>
-              </tr>
-              <tr v-if="IPLocation.geocn && (IPLocation.geocn.administrative_area || IPLocation.geocn.city || IPLocation.geocn.district)">
-                <td class="table-label">GeoCN(仅中国大陆)</td>
-                <td class="table-value">{{ IPLocation.geocn?.administrative_area }}&nbsp;{{ IPLocation.geocn?.city }}&nbsp;{{ IPLocation.geocn?.district }}</td>
-                <td class="table-value">{{ IPLocation.geocn?.isp }}</td>
-              </tr>
-              <tr v-if="IPLocation.maxmind_city && IPLocation.maxmind_asn && (IPLocation.maxmind_city.country || IPLocation.maxmind_city.city)">
-                <td class="table-label">Maxmind GEOLite2 City</td>
-                <td class="table-value">{{ IPLocation.maxmind_city?.country }}&nbsp;{{ IPLocation.maxmind_city?.administrative_area }}&nbsp;{{ IPLocation.maxmind_city?.city }}</td>
-                <td class="table-value">{{ IPLocation.maxmind_asn?.org }}</td>
-              </tr>
-              <tr v-if="IPLocation.qqwry && (IPLocation.qqwry.country || IPLocation.qqwry.administrative_area || IPLocation.qqwry.city)">
-                <td class="table-label">纯真社区库</td>
-                <td class="table-value">{{ IPLocation.qqwry?.country }}&nbsp;{{ IPLocation.qqwry?.administrative_area }}&nbsp;{{ IPLocation.qqwry?.city }}</td>
-                <td class="table-value">{{ IPLocation.qqwry?.isp }}</td>
-              </tr>
-              <tr v-if="IPLocation.dbip_city && (IPLocation.dbip_city.administrative_area || IPLocation.dbip_city.city)">
-                <td class="table-label">DB-IP City</td>
-                <td class="table-value">{{ IPLocation.dbip_city?.country }}&nbsp;{{ IPLocation.dbip_city?.administrative_area }}&nbsp;{{ IPLocation.dbip_city?.city }}</td>
-                <td class="table-value">{{IPLocation.dbip_asn?.org || '--'}}</td>
-              </tr>
-            </tbody>
-          </table>
-        </div>
-    </div>
-    <div style="font-size: 1.5em;">
-      <h3 v-if="isIPv6(UserIP)"><el-icon><CircleCheckFilled style="color: lightgreen;"/></el-icon>您的网络IPv6优先</h3>
-      <h3 v-else-if="isIPv4(UserIP)"><el-icon><CircleCloseFilled style="color: red;"/></el-icon>您的网络IPv4优先</h3>
-    </div>
-    <blockquote>
-      精度参照表：<br>
-      中国大陆:BiliBili Live > GeoCN > IP2Region > 纯真社区库 > Maxmind GEOLite2 City ≈ DB-IP<br>
-      中国大陆 IPv6 地址: BiliBili Live > GeoCN > IP2Region > Maxmind GEOLite2 City ≈ DB-IP > 纯真社区库<br>
-      境外及港澳台地址: Maxmind GEOLite2 City ≈ DB-IP > BiliBili Live >  > IP2Region > 纯真社区库<br>
-      
-      手机默认开启 IPv6，宽带开启 IPv6 请自行搜索<br>
-      访客IP: {{UserIP}}，<p v-if="isIPv4(UserIP)">您的网络IPv4优先</p><p v-else-if="isIPv6(UserIP)">您的网络IPv6优先</p>
-    </blockquote>
-
-    <div v-html="html"></div>
-
-    </div>
-
-
-
+  <div class="redirecting">正在跳转到 IP 归属地查询…</div>
 </template>
+
 <style scoped>
-@import "../style.css";
-@import "../../assets/css/tool-common.css";
-</style>
-<style>
-@import "../style.css";
-:root {
-  --el-color-primary: #3EAF7C;
-}
-.el-icon{
-  font-size: 1.3em;
-}
-.el-menu--horizontal > .el-menu-item:nth-child(1) {
-  margin-right: auto;
-}
-
-.el-input {
-  width: 420px;
-  height: 50px;
-  font: 1.3em sans-serif;
-  margin-right: 10px;
-}
-
-.el-button {
-  width: 165px;
-  height: 50px;
-  font: 1.3em sans-serif;
-}
-
-.result-section {
-  margin-top: 30px;
-}
-
-.result-table {
-  width: 100%;
-  border-collapse: collapse;
-  background: #fff;
-  border: 1px solid #dcdfe6;
-}
-html.dark .result-table {
-  width: 100%;
-  border-collapse: collapse;
-  background: #2e2d2d;
-  border: 1px solid #2e2e2e;
-}
-.result-table thead tr {
-  background-color: #c0c4cc;
-}
-html.dark .result-table thead tr {
-    background: #2e2d2d;
-}
-
-.result-table .table-header {
-  padding: 12px 15px;
-  font-weight: 600;
-  color: #303133;
-  text-align: left;
-  border: 1px solid #dcdfe6;
-}
-html.dark .result-table .table-header {
-  padding: 12px 15px;
-  font-weight: 600;
-  color: #cfcfcf;
-  text-align: left;
-  border: 1px solid #1a1919;
-}
-
-.result-table tbody tr {
-  border-bottom: 1px solid #dcdfe6;
-}
-html.dark .result-table tbody tr {
-  border-bottom: 1px solid #1a1919;
-}
-
-
-.result-table tbody tr:last-child {
-  border-bottom: none;
-}
-
-.result-table tbody tr:hover {
-  background-color: #f5f7fa;
-}
-html.dark .result-table tbody tr:hover {
-  background-color: #393a3a;
-}
-
-.result-table .table-label {
-  padding: 12px 15px;
-  font-weight: 600;
-  color: #606266;
-  width: 150px;
-  text-align: left;
-  border: 1px solid #dcdfe6;
-}
-html.dark .result-table .table-label {
-  color: #c0c4cc;
-  border: 1px solid #1a1919;
-}
-
-.result-table .table-value {
-  padding: 12px 15px;
-  color: #303133;
-  border: 1px solid #dcdfe6;
-}
-html.dark .result-table .table-value {
-  color: #cfcfcf;
-  border: 1px solid #1a1919;
-}
-.valid {
-  color: #67C23A;
-  font-weight: 600;
-}
-
-.expired {
-  color: #F56C6C;
-  font-weight: 600;
-}
-
-.status-code {
-  font-weight: 600;
-  padding: 4px 12px;
-  border-radius: 4px;
-}
-
-.status-success {
-  color: #67C23A;
-  background: #f0f9eb;
-}
-
-.status-warning {
-  color: #E6A23C;
-  background: #fdf6ec;
-}
-
-.status-error {
-  color: #F56C6C;
-  background: #fef0f0;
-}
-
-.error-message {
-  margin-top: 20px;
-  padding: 15px;
-  background: #fef0f0;
-  color: #F56C6C;
-  border-radius: 6px;
-  text-align: center;
-  font-size: 1.1em;
-}
-
-pre {
-  background: #f8f9fa;
-  padding: 15px;
-  border-radius: 6px;
-  overflow-x: auto;
-  white-space: pre;
-  max-width: 100%;
-}
-
-pre code {
-  font-family: 'JetBrains Mono', 'Fira Code', 'Consolas', monospace;
-  font-size: 0.9em;
-  color: #303133;
-}
-html.dark pre {
-  background: #303133;
-}
-
-html.dark pre code {
-  font-family: 'JetBrains Mono', 'Fira Code', 'Consolas', monospace;
-  color: #f8f9fa;
-}
-
-
-
-.badge-section {
+.redirecting {
   display: flex;
-  flex-direction: column;
-  gap: 20px;
-  margin-top: 20px;
+  align-items: center;
+  justify-content: center;
+  min-height: 50vh;
+  color: #999;
 }
-
-.badge-item {
-  background: #fff;
-  padding: 20px;
-  border-radius: 8px;
-  border: 1px solid #e4e7ed;
-}
-
-.badge-item h4 {
-  margin: 0 0 15px 0;
-  color: #3EAF7C;
-  font-size: 1.2em;
-}
-
-.badge-item img {
-  display: block;
-  margin-bottom: 15px;
-  max-width: 200px;
-}
-</style>
+</style>

frontend-ssr/app/pages/ipv6speedtest.vue

@@ -57,6 +57,9 @@ interface ServerResult {
   data: any
 }
 
+// 查询序号：连续点击时旧查询的结果不允许写入新查询的结果表
+let queryId = 0
+
 /** 预构建的服务器列表，页面挂载即展示，用户可提前看到测速节点 */
 const serverResults = ref<ServerResult[]>([])
 
@@ -68,8 +71,8 @@ const serverResults = ref<ServerResult[]>([])
 // =============================================
 
 /** 双栈服务器：同时支持 IPv4/IPv6 的节点 */
-const dualStackFetches = config.SpeedTest.DualStack.map((server) => {
-  const url = computed(() => "/middleware/" + server.id + "/speed/v6/" + domain.value);
+const dualStackFetches = config.APIBaseURL.DualStack.map((server) => {
+  const url = computed(() => "/middleware/" + server.id + "/speed/v6/" + encodeURIComponent(domain.value));
   const { data, error: fetchError, execute } = useMiddlewareFetch(url, {
     immediate: false,
     watch: false,
@@ -78,8 +81,8 @@ const dualStackFetches = config.SpeedTest.DualStack.map((server) => {
 });
 
 /** IPv6 专用服务器：仅支持 IPv6 的节点 */
-const ipv6Fetches = config.SpeedTest.IPv6.map((server) => {
-  const url = computed(() => "/middleware/" + server.id + "/speed/v6/" + domain.value);
+const ipv6Fetches = config.APIBaseURL.IPv6.map((server) => {
+  const url = computed(() => "/middleware/" + server.id + "/speed/v6/" + encodeURIComponent(domain.value));
   const { data, error: fetchError, execute } = useMiddlewareFetch(url, {
     immediate: false,
     watch: false,
@@ -116,6 +119,8 @@ async function SpeedTest() {
   error.value = ''
   await nextTick()
 
+  const id = ++queryId
+
   // 重置所有行状态为加载中
   serverResults.value.forEach((row) => {
     row.loading = true
@@ -130,16 +135,26 @@ async function SpeedTest() {
 
     try {
       await fetch.execute();
-      row.data = fetch.data.value;
+      if (id !== queryId) return
+      // execute() 不会抛错，失败以 error.value 为准（否则故障节点渲染成空白）
+      if (fetch.error.value) {
+        row.error = fetch.error.value?.data?.error || fetch.error.value?.message || '请求失败';
+      } else {
+        row.data = fetch.data.value;
+      }
     } catch (err: any) {
       row.error = err?.data?.error || err?.message || '请求失败';
     } finally {
-      row.loading = false;
+      if (id === queryId) {
+        row.loading = false;
+      }
     }
   });
 
   Promise.all(promises).finally(() => {
-    loading.value = false
+    if (id === queryId) {
+      loading.value = false
+    }
   })
 }
 

frontend-ssr/app/pages/ipv6tcping.vue

@@ -77,14 +77,16 @@ const port = ref('80')
 const userIP = ref('')
 const loading = ref(false)
 const serverResults = ref<ServerResult[]>([])
+// 查询序号：连续点击时旧查询的结果不允许写入新查询的结果表
+let queryId = 0
 
 const allServers = [
-  ...config.TCPing.DualStack.map((s: ServerConfig) => ({ ...s, type: 'DualStack' })),
-  ...config.TCPing.IPv6.map((s: ServerConfig) => ({ ...s, type: 'IPv6' }))
+  ...config.APIBaseURL.DualStack.map((s: ServerConfig) => ({ ...s, type: 'DualStack' })),
+  ...config.APIBaseURL.IPv6.map((s: ServerConfig) => ({ ...s, type: 'IPv6' }))
 ];
 
 const tcpingFetches = allServers.map((server) => {
-  const url = computed(() => "/middleware/" + server.id + "/tcping/" + extractHost(tmpDomain.value) + "?port=" + port.value);
+  const url = computed(() => "/middleware/" + server.id + "/tcping/" + encodeURIComponent(extractHost(tmpDomain.value)) + "?port=" + encodeURIComponent(port.value));
   const { data, error: fetchError, execute } = useMiddlewareFetch<TCPingResponse>(url, {
     immediate: false,
     watch: false,
@@ -95,7 +97,7 @@ const tcpingFetches = allServers.map((server) => {
 function initServerResults() {
   const results: ServerResult[] = []
   
-  config.TCPing.DualStack.forEach((server: ServerConfig) => {
+  config.APIBaseURL.DualStack.forEach((server: ServerConfig) => {
     results.push({
       label: server.label,
       loading: false,
@@ -103,7 +105,7 @@ function initServerResults() {
     })
   })
   
-  config.TCPing.IPv6.forEach((server: ServerConfig) => {
+  config.APIBaseURL.IPv6.forEach((server: ServerConfig) => {
     results.push({
       label: server.label,
       loading: false,
@@ -117,23 +119,31 @@ function initServerResults() {
 function TCPingAll() {
   const host = extractHost(tmpDomain.value)
   if (!host) return
-  
+
   loading.value = true
-  
+
+  const id = ++queryId
+
   serverResults.value.forEach((result) => {
     result.loading = true
     result.error = ''
     result.ipv4 = undefined
     result.ipv6 = undefined
   })
-  
+
   const promises = tcpingFetches.map(async (fetch, index) => {
     try {
       await fetch.execute();
+      if (id !== queryId) return
       const result = serverResults.value[index];
       if (result) {
-        result.ipv4 = fetch.data.value?.ipv4;
-        result.ipv6 = fetch.data.value?.ipv6;
+        // execute() 不会抛错，失败以 error.value 为准（否则故障节点渲染成 '-'）
+        if (fetch.error.value) {
+          result.error = (fetch.error.value as any)?.message || '请求失败';
+        } else {
+          result.ipv4 = fetch.data.value?.ipv4;
+          result.ipv6 = fetch.data.value?.ipv6;
+        }
       }
     } catch (err) {
       console.error(err);
@@ -143,22 +153,24 @@ function TCPingAll() {
       }
     } finally {
       const result = serverResults.value[index];
-      if (result) {
+      if (result && id === queryId) {
         result.loading = false;
       }
     }
   })
-  
+
   Promise.all(promises).finally(function () {
-    loading.value = false
+    if (id === queryId) {
+      loading.value = false
+    }
   })
 }
 async function getUserIP(){
-  
-  await $fetch<string>(config.DualStackAPI).then(
-  function (data){
-    userIP.value = data
-  })
+  try {
+    userIP.value = await $fetch<string>(config.DualStackAPI)
+  } catch {
+    // 获取失败保持为空，避免未处理的 Promise 拒绝
+  }
   return userIP.value
 }
 onMounted(() => {
@@ -221,13 +233,13 @@ onMounted(() => {
               <td class="table-value">{{ server.ipv6.sent }}</td>
               <td class="table-value">{{ server.ipv6.success }}</td>
               <td class="table-value">
-                <span :class="server.ipv6.loss_rate > 0 ? 'loss-warning' : 'loss-ok'">
-                  {{ server.ipv6.loss_rate.toFixed(1) }}
+                <span :class="(server.ipv6?.loss_rate ?? 0) > 0 ? 'loss-warning' : 'loss-ok'">
+                  {{ server.ipv6?.loss_rate?.toFixed(1) ?? '-' }}
                 </span>
               </td>
-              <td class="table-value">{{ server.ipv6.max_rtt.toFixed(2) }}</td>
-              <td class="table-value">{{ server.ipv6.min_rtt.toFixed(2) }}</td>
-              <td class="table-value">{{ server.ipv6.avg_rtt.toFixed(2) }}</td>
+              <td class="table-value">{{ server.ipv6?.max_rtt?.toFixed(2) ?? '-' }}</td>
+              <td class="table-value">{{ server.ipv6?.min_rtt?.toFixed(2) ?? '-' }}</td>
+              <td class="table-value">{{ server.ipv6?.avg_rtt?.toFixed(2) ?? '-' }}</td>
             </tr>
             <tr v-else-if="server.loading">
               <td class="table-label">{{ server.label }}</td>

frontend-ssr/app/pages/ipv6webcheck.vue

@@ -63,7 +63,7 @@ interface PerformanceCheckItem {
   download_speed: number
   is_reachable: boolean
 }
-const apiList = config.apiBaseUrls
+const apiList = config.APIBaseURL.DualStack
 const currentApiIndex = ref(0)
 const backendID = computed(() => apiList[currentApiIndex.value]?.id || '')
 const tmpDomain = ref('https://www.zakoflare.com')
@@ -72,6 +72,8 @@ const loading = ref(false)
 const error = ref('')
 const result = ref<PerformanceCheckResponse | null>(null)
 const checkUrl = computed(() => "/middleware/" + backendID.value + "/detail/" + testDomain.value);
+// testDomain 是完整 URL（含 https:// 与路径斜杠），服务端 [...slug].get.ts 依赖
+// 分段重组协议部分，这里刻意不做 encodeURIComponent
 
 const { data: checkData, error: checkError, execute: executeCheck } = useMiddlewareFetch<PerformanceCheckResponse>(checkUrl, {
   immediate: false,
@@ -162,7 +164,7 @@ onMounted(() => {
           <tr>
             <td class="table-label">主机记录</td>
             <td class="table-value"><div class="one-line"><RouterLink :to="`/ipv6?ip=${result.ipv4!.host_record}`">{{ result.ipv4!.host_record }}</RouterLink><el-icon><Position /></el-icon></div></td>
-            <td class="table-value"><div class="one-line"><RouterLink :to="`/ipv6?ip=${result.ipv6?.host_record}`">{{ result.ipv6?.host_record || '-' }}</RouterLink><el-icon><Position /></el-icon></div></td>
+            <td class="table-value"><div class="one-line"><RouterLink v-if="result.ipv6?.host_record" :to="`/ipv6?ip=${result.ipv6!.host_record}`">{{ result.ipv6!.host_record }}</RouterLink><span v-else>-</span><el-icon><Position /></el-icon></div></td>
           </tr>
           <tr>
             <td class="table-label">HTTP 状态码</td>
@@ -275,6 +277,12 @@ onMounted(() => {
       <h2>...</h2>
       <el-image src="/jingya.jpg"></el-image>
     </div>
+    <div v-else-if="result && result.ipv4 && result.ipv6 && !result.ipv4.is_reachable && result.ipv6.is_reachable">
+      <h3>结论：<CircleCloseFilled style="width: 1.3em;color: red;"/>网站{{ extractHost(testDomain) }} 不支持IPv4访问 </h3>
+      <h2>全球来看，越南、捷克等部分国家已提出了单栈发展目标。尽管我国网络IPv6流量占比大幅提升，但网络中仍存在大量的NAT（网络地址转换）设备和IPv4依赖应用。</h2>
+      <h2 style="text-align: right;">----中国《IPv6发展报告》2026</h2>
+      <el-image src="/jingya.jpg"></el-image>
+    </div>
     <blockquote>
       网站不支持 IPv6可能原因：<br/>
       <br/>

frontend-ssr/app/pages/location.vue

@@ -49,6 +49,8 @@ interface IPLocationType {
   ip?: string;
   geocn?: any;
   ip2region?: any;
+  ip2location?: any;
+  ip2location_asn?: any;
   maxmind_asn?: any;
   maxmind_city?: any;
   qqwry?: any;
@@ -67,14 +69,14 @@ curl ${config.v6OnlyAPI}
 curl ${config.DualStackAPI}
 `.trim();
 const html = ref('');
-const apiList = config.IPLocationAPIs
+const apiList = config.IPLocationAPI
 const currentApiIndex = ref(0)
 const backendID = computed(() => apiList[currentApiIndex.value]?.id || '')
 const ipAddress = ref('');
 const IPLocation = ref<IPLocationType>({});
 const UserIP = ref('');
 const error = ref('')
-const locationUrl = computed(() => "/middleware/" + backendID.value + "/location/" + ipAddress.value);
+const locationUrl = computed(() => "/middleware/" + backendID.value + "/location/" + encodeURIComponent(ipAddress.value));
 
 const { data: locationData, error: locationError, execute: executeLocation } = useMiddlewareFetch<IPLocationType>(locationUrl, {
   immediate: false,
@@ -182,10 +184,15 @@ onMounted(async () => {
                   </span>
                 </td>
               </tr>
-              <tr v-if="IPLocation.ip2region && IPLocation.ip2region.split('|').length >= 4">
+              <tr v-if="IPLocation.ip2region && typeof IPLocation.ip2region === 'object' && (IPLocation.ip2region.administrative_area || IPLocation.ip2region.city)">
                 <td class="table-label">IP2Region</td>
-                <td class="table-value">{{ IPLocation.ip2region?.split("|")[0] }}&nbsp;{{ IPLocation.ip2region?.split("|")[1] }}&nbsp;{{ IPLocation.ip2region?.split("|")[2] }}</td>
-                <td class="table-value">{{ IPLocation.ip2region?.split("|")[3] }}</td>
+                <td class="table-value">{{ IPLocation.ip2region?.country }}&nbsp;{{ IPLocation.ip2region?.administrative_area }}&nbsp;{{ IPLocation.ip2region?.city }}</td>
+                <td class="table-value">{{ IPLocation.ip2region?.isp }}</td>
+              </tr>
+              <tr v-if="IPLocation.ip2location && typeof IPLocation.ip2location === 'object' && (IPLocation.ip2location.administrative_area || IPLocation.ip2location.city)">
+                <td class="table-label">IP2Location</td>
+                <td class="table-value">{{ IPLocation.ip2location?.country }}&nbsp;{{ IPLocation.ip2location?.administrative_area }}&nbsp;{{ IPLocation.ip2location?.city }}</td>
+                <td class="table-value">{{ IPLocation.ip2location_asn?.as }}</td>
               </tr>
               <tr v-if="IPLocation.geocn && (IPLocation.geocn.administrative_area || IPLocation.geocn.city || IPLocation.geocn.district)">
                 <td class="table-label">GeoCN(仅中国大陆)</td>

frontend-ssr/app/pages/screenshot.vue

@@ -32,17 +32,18 @@ let detectionImg: HTMLImageElement | null = null
 let detectionTimeout: ReturnType<typeof setTimeout> | null = null
 let currentRequestId = 0
 const userIP = ref('')
-// WordPress mshots default error image dimensions
-const DEFAULT_MSHOTS_WIDTH = 400
-const DEFAULT_MSHOTS_HEIGHT = 300
+// WordPress mshots 默认占位图（生成失败/重定向目标）的尺寸是 1200x900，
+// 与下方注释及判定逻辑一致；真实网站截图可以是任意尺寸
+const DEFAULT_MSHOTS_WIDTH = 1200
+const DEFAULT_MSHOTS_HEIGHT = 900
 const LOADING_TIMEOUT = 15000 // 15 seconds
 
 async function getUserIP(){
-  
-  await $fetch<string>(config.DualStackAPI).then(
-  function (data){
-    userIP.value = data
-  })
+  try {
+    userIP.value = await $fetch<string>(config.DualStackAPI)
+  } catch {
+    // 获取失败保持为空，避免未处理的 Promise 拒绝
+  }
   return userIP.value
 }
 function cleanupDetection() {

frontend-ssr/app/pages/speedtest.vue

@@ -57,6 +57,9 @@ interface ServerResult {
   data: any
 }
 
+// 查询序号：连续点击时旧查询的结果不允许写入新查询的结果表
+let queryId = 0
+
 /** 预构建的服务器列表，页面挂载即展示，用户可提前看到测速节点 */
 const serverResults = ref<ServerResult[]>([])
 
@@ -68,8 +71,8 @@ const serverResults = ref<ServerResult[]>([])
 // =============================================
 
 /** 双栈服务器：同时支持 IPv4/IPv6 的节点 */
-const dualStackFetches = config.SpeedTest.DualStack.map((server) => {
-  const url = computed(() => "/middleware/" + server.id + "/speed/v4/" + domain.value);
+const dualStackFetches = config.APIBaseURL.DualStack.map((server) => {
+  const url = computed(() => "/middleware/" + server.id + "/speed/v4/" + encodeURIComponent(domain.value));
   const { data, error: fetchError, execute } = useMiddlewareFetch(url, {
     immediate: false,
     watch: false,
@@ -78,8 +81,8 @@ const dualStackFetches = config.SpeedTest.DualStack.map((server) => {
 });
 
 /** IPv4 专用服务器：仅支持 IPv4 的节点 */
-const ipv4Fetches = config.SpeedTest.IPv4.map((server) => {
-  const url = computed(() => "/middleware/" + server.id + "/speed/v4/" + domain.value);
+const ipv4Fetches = config.APIBaseURL.IPv4.map((server) => {
+  const url = computed(() => "/middleware/" + server.id + "/speed/v4/" + encodeURIComponent(domain.value));
   const { data, error: fetchError, execute } = useMiddlewareFetch(url, {
     immediate: false,
     watch: false,
@@ -116,6 +119,8 @@ async function SpeedTest() {
   error.value = ''
   await nextTick()
 
+  const id = ++queryId
+
   // 重置所有行状态为加载中
   serverResults.value.forEach((row) => {
     row.loading = true
@@ -130,16 +135,26 @@ async function SpeedTest() {
 
     try {
       await fetch.execute()
-      row.data = fetch.data.value
+      if (id !== queryId) return
+      // execute() 不会抛错，失败以 error.value 为准（否则故障节点渲染成空白）
+      if (fetch.error.value) {
+        row.error = fetch.error.value?.data?.error || fetch.error.value?.message || '请求失败'
+      } else {
+        row.data = fetch.data.value
+      }
     } catch (err: any) {
       row.error = err?.data?.error || err?.message || '请求失败'
     } finally {
-      row.loading = false
+      if (id === queryId) {
+        row.loading = false
+      }
     }
   })
 
   Promise.all(promises).finally(() => {
-    loading.value = false
+    if (id === queryId) {
+      loading.value = false
+    }
   })
 }
 

frontend-ssr/app/pages/ssl.vue

@@ -65,7 +65,7 @@ interface SSLCheckItem {
   is_expired: boolean
   is_reachable: boolean
 }
-const apiList = config.apiBaseUrls
+const apiList = config.APIBaseURL.DualStack
 const currentApiIndex = ref(0)
 const backendID = computed(() => apiList[currentApiIndex.value]?.id || '')
 const tmpDomain = ref('https://www.zakoflare.com')
@@ -73,7 +73,7 @@ const testDomain = ref('')
 const loading = ref(false)
 const error = ref('')
 const result = ref<SSLCheckResponse | null>(null)
-const sslUrl = computed(() => "/middleware/" + backendID.value + "/ssl/" + testDomain.value);
+const sslUrl = computed(() => "/middleware/" + backendID.value + "/ssl/" + encodeURIComponent(testDomain.value));
 
 const { data: sslData, error: sslError, execute: executeSSL } = useMiddlewareFetch<SSLCheckResponse>(sslUrl, {
   immediate: false,

frontend-ssr/app/pages/tcping.vue

@@ -76,14 +76,16 @@ const tmpDomain = ref('www.zakoflare.com')
 const port = ref('80')
 const loading = ref(false)
 const serverResults = ref<ServerResult[]>([])
+// 查询序号：连续点击时旧查询的结果不允许写入新查询的结果表
+let queryId = 0
 
 const allServers = [
-  ...config.TCPing.DualStack.map((s: ServerConfig) => ({ ...s, type: 'DualStack' })),
-  ...config.TCPing.IPv4.map((s: ServerConfig) => ({ ...s, type: 'IPv4' }))
+  ...config.APIBaseURL.DualStack.map((s: ServerConfig) => ({ ...s, type: 'DualStack' })),
+  ...config.APIBaseURL.IPv4.map((s: ServerConfig) => ({ ...s, type: 'IPv4' }))
 ];
 
 const tcpingFetches = allServers.map((server) => {
-  const url = computed(() => "/middleware/" + server.id + "/tcping/" + extractHost(tmpDomain.value) + "?port=" + port.value);
+  const url = computed(() => "/middleware/" + server.id + "/tcping/" + encodeURIComponent(extractHost(tmpDomain.value)) + "?port=" + encodeURIComponent(port.value));
   const { data, error: fetchError, execute } = useMiddlewareFetch<TCPingResponse>(url, {
     immediate: false,
     watch: false,
@@ -94,7 +96,7 @@ const tcpingFetches = allServers.map((server) => {
 function initServerResults() {
   const results: ServerResult[] = []
   
-  config.TCPing.DualStack.forEach((server: ServerConfig) => {
+  config.APIBaseURL.DualStack.forEach((server: ServerConfig) => {
     results.push({
       label: server.label,
       loading: false,
@@ -102,7 +104,7 @@ function initServerResults() {
     })
   })
   
-  config.TCPing.IPv4.forEach((server: ServerConfig) => {
+  config.APIBaseURL.IPv4.forEach((server: ServerConfig) => {
     results.push({
       label: server.label,
       loading: false,
@@ -116,23 +118,31 @@ function initServerResults() {
 function TCPingAll() {
   const host = extractHost(tmpDomain.value)
   if (!host) return
-  
+
   loading.value = true
-  
+
+  const id = ++queryId
+
   serverResults.value.forEach((result) => {
     result.loading = true
     result.error = ''
     result.ipv4 = undefined
     result.ipv6 = undefined
   })
-  
+
   const promises = tcpingFetches.map(async (fetch, index) => {
     try {
       await fetch.execute();
+      if (id !== queryId) return
       const result = serverResults.value[index];
       if (result) {
-        result.ipv4 = fetch.data.value?.ipv4;
-        result.ipv6 = fetch.data.value?.ipv6;
+        // execute() 不会抛错，失败以 error.value 为准（否则故障节点渲染成 '-'）
+        if (fetch.error.value) {
+          result.error = (fetch.error.value as any)?.message || '请求失败';
+        } else {
+          result.ipv4 = fetch.data.value?.ipv4;
+          result.ipv6 = fetch.data.value?.ipv6;
+        }
       }
     } catch (err) {
       console.error(err);
@@ -142,14 +152,16 @@ function TCPingAll() {
       }
     } finally {
       const result = serverResults.value[index];
-      if (result) {
+      if (result && id === queryId) {
         result.loading = false;
       }
     }
   })
-  
+
   Promise.all(promises).finally(function () {
-    loading.value = false
+    if (id === queryId) {
+      loading.value = false
+    }
   })
 }
 
@@ -212,13 +224,13 @@ onMounted(() => {
               <td class="table-value">{{ server.ipv4?.sent }}</td>
               <td class="table-value">{{ server.ipv4?.success }}</td>
               <td class="table-value">
-                <span :class="server.ipv4.loss_rate > 0 ? 'loss-warning' : 'loss-ok'">
-                  {{ server.ipv4.loss_rate.toFixed(1) }}
+                <span :class="(server.ipv4?.loss_rate ?? 0) > 0 ? 'loss-warning' : 'loss-ok'">
+                  {{ server.ipv4?.loss_rate?.toFixed(1) ?? '-' }}
                 </span>
               </td>
-              <td class="table-value">{{ server.ipv4?.max_rtt.toFixed(2) }}</td>
-              <td class="table-value">{{ server.ipv4?.min_rtt.toFixed(2) }}</td>
-              <td class="table-value">{{ server.ipv4?.avg_rtt.toFixed(2) }}</td>
+              <td class="table-value">{{ server.ipv4?.max_rtt?.toFixed(2) ?? '-' }}</td>
+              <td class="table-value">{{ server.ipv4?.min_rtt?.toFixed(2) ?? '-' }}</td>
+              <td class="table-value">{{ server.ipv4?.avg_rtt?.toFixed(2) ?? '-' }}</td>
             </tr>
             <tr v-else-if="server.loading">
               <td class="table-label">{{ server.label }}</td>

frontend-ssr/app/pages/whois.vue

@@ -64,10 +64,10 @@ const result = ref<any>(null)
 const error = ref('')
 const userIP = ref('')
 
-const apiList = config.apiBaseUrls
+const apiList = config.APIBaseURL.DualStack
 const currentApiIndex = ref(0)
 const backendID = computed(() => apiList[currentApiIndex.value]?.id || '')
-const whoisUrl = computed(() => '/middleware/' + backendID.value + '/whois/' + domain.value)
+const whoisUrl = computed(() => '/middleware/' + backendID.value + '/whois/' + encodeURIComponent(domain.value))
 
 const { data: whoisData, error: whoisError, execute: executeWhois } = useMiddlewareFetch<any>(whoisUrl, {
   immediate: false,
@@ -124,11 +124,11 @@ onMounted(() => {
 })
 
 async function getUserIP(){
-  await $fetch<string>(config.DualStackAPI).then(
-    function (data){
-      userIP.value = data
-    }
-  )
+  try {
+    userIP.value = await $fetch<string>(config.DualStackAPI)
+  } catch {
+    // 获取失败保持为空，避免未处理的 Promise 拒绝
+  }
   return userIP.value
 }
 

frontend-ssr/config/index.ts

@@ -19,7 +19,7 @@ const config = {
     // 未配置或为空数组时，直接使用前端自带中间件。
     Middleware: <string[]>[
         "https://middleware-1.api-ipw.wsmdn.top/"
-        // "http://127.0.0.1:8091/",
+        // "http://127.0.0.1:8092/",
         // "https://middleware-2.wsmdn.top/",
     ],
     // Umami 统计
@@ -35,29 +35,18 @@ const config = {
     v4OnlyAPI: "https://4.wsmdn.top",
     v6OnlyAPI: "https://6.wsmdn.top",
     DualStackAPI: "https://test.wsmdn.top",
-    apiBaseUrls: [
+    // ---- 节点池结构 ----
+    // IPLocationAPI：IP 归属查询（location / asn）上游节点池（纯数组，无栈区分）
+    IPLocationAPI: [
         {
             label: "中国 江苏 移动",
             id: "cn-jiangsu",
             url: "https://cn-jiangsu.api-ipw.wsmdn.top/"
         },
         {
-            label: "中国 广东 深圳 龙岗 坪地街道 中国移动",
-            id: "cn-shenzhen",
-            url: "https://cn-shenzhen.api-ipw.wsmdn.top/"
-        },
-        // IP 直连新节点：URL 留空，仅经独立中间件转发
-        {
-            label: "上海 腾讯云 BGP",
-            id: "tencent-sh",
+            label: "中国 湖北 武汉 电信",
+            id: "cn-wuhan-chinatelecom",
             url: ""
-        }
-    ],
-    IPLocationAPIs: [
-        {
-            label: "中国 江苏 移动",
-            id: "cn-jiangsu",
-            url: "https://cn-jiangsu.api-ipw.wsmdn.top/"
         },
         {
             label: "中国 四川 沙渠 电信[ZFC]",
@@ -65,283 +54,103 @@ const config = {
             url: "https://cn2-sichuan.api-ipw.wsmdn.top/"
         }
     ],
-    TCPing:{
-        DualStack: [
+    // APIBaseURL：其余拨测（whois / ssl / detail / dns / dnssec / tcping / speed）上游节点池，含 { IPv6, IPv4, DualStack } 三栈
+    APIBaseURL: {
+        IPv6: [
             {
-                label: "中国 江苏 移动",
-                id: "cn-jiangsu",
-                url :"https://cn-jiangsu.api-ipw.wsmdn.top/",
+                label: "中国 四川 沙渠 电信[ZFC]",
+                id: "cn2-sichuan",
+                url: "https://cn2-sichuan.api-ipw.wsmdn.top/"
             },
             {
-                label: "中国 广东 深圳 龙岗 坪地街道 中国移动",
-                id: "cn-shenzhen",
-                url :"https://cn-shenzhen.api-ipw.wsmdn.top/",
+                label: "中国 香港 九龙城区 旺角东 Cloudie[ZFC]",
+                id: "lntl-cn-hk-kowloon",
+                url: "https://lntl-cn-hk-kowloon.api-ipw.wsmdn.top/"
             },
-            // IP 直连新节点：URL 留空，仅经独立中间件转发
             {
-                label: "上海 腾讯云 BGP",
-                id: "tencent-sh",
-                url :"",
-            },
+                label: "中国 河北 秦皇岛 联通",
+                id: "cn-hebei-qinhuangdao",
+                url: "https://cn-hebei-qinhuangdao.api-ipw.wsmdn.top/"
+            }
         ],
         IPv4: [
             {
                 label: "中国 广东 广州 腾讯云",
                 id: "cn-guangzhou",
-                url :"https://cn-guangzhou.api-ipw.wsmdn.top/",
+                url: "https://cn-guangzhou.api-ipw.wsmdn.top/"
             },
             {
                 label: "新加坡 腾讯云",
                 id: "sg-1",
-                url :"https://sg-1.api-ipw.wsmdn.top/",
+                url: "https://sg-1.api-ipw.wsmdn.top/"
             },
             {
                 label: "中国 香港 新界 西贡区 将军澳 MICC[ZFC]",
                 id: "hk-shatin",
-                url :"https://china-hk-kowloon-shatindistrict-newcloud.ipwapi.zfap.wsmdn.top/",
+                url: "https://china-hk-kowloon-shatindistrict-newcloud.ipwapi.zfap.wsmdn.top/"
             },
             {
                 label: "中国 陕西 西安 北经济技术开发区 未央区凤城 中国电信[ZFC]",
                 id: "cn-xian",
-                url :"https://cn-xian-shaanxiprovince.api-ipw.wsmdn.top/",
+                url: "https://cn-xian-shaanxiprovince.api-ipw.wsmdn.top/"
             },
             {
-                label: "美国/加利福尼亚州/洛杉矶/蒙特雷帕克/USCD[ZFC]",
+                label: "美国/加利福尼亚州/洛杉矶/蒙特利奇帕克/USCD[ZFC]",
                 id: "us-la",
-                url :"https://america-california-losangeles.ipwapi.zfap.wsmdn.top/",
+                url: "https://america-california-losangeles.ipwapi.zfap.wsmdn.top/"
             },
             // IP 直连新节点：URL 留空，仅经独立中间件转发
             {
                 label: "山东 枣庄 双线",
                 id: "zaozhuang",
-                url :"",
+                url: ""
             },
             {
                 label: "湖北 十堰 电信",
                 id: "shiyan",
-                url :"",
-            },
-            {
-                label: "香港 VpsQuan",
-                id: "hongkong2",
-                url :"",
-            },
-            {
-                label: "北京 京东云 BGP",
-                id: "jdcloud",
-                url :"",
+                url: ""
             },
             {
                 label: "陕西 西安二 电信",
                 id: "xian2",
-                url :"",
+                url: ""
             },
             {
                 label: "香港 Cogent",
                 id: "hongkong",
-                url :"",
+                url: ""
+            },
+            // WS 通道节点：URL 留空，拨测经中间件 WS 转发
+            {
+                label: "呼和浩特移动",
+                id: "2faa15e6-18a7-4355-b422-ca53277d8d77",
+                url: ""
             }
         ],
-        IPv6: [
-            {
-                label: "中国 四川 沙渠 电信[ZFC]",
-                id: "cn2-sichuan",
-                url:"https://cn2-sichuan.api-ipw.wsmdn.top/",
-            },
-            {
-                label: "中国 香港 九龙城区 旺角东 Cloudie[ZFC]",
-                id: "lntl-cn-hk-kowloon",
-                url:"https://lntl-cn-hk-kowloon.api-ipw.wsmdn.top/",
-            },
-            {
-                label: "中国 河北 秦皇岛 联通",
-                id: "cn-hebei-qinhuangdao",
-                url :"https://cn-hebei-qinhuangdao.api-ipw.wsmdn.top/",
-            }
-        ]
-    },
-    SpeedTest:{
         DualStack: [
+
             {
                 label: "中国 江苏 移动",
                 id: "cn-jiangsu",
-                url :"https://cn-jiangsu.api-ipw.wsmdn.top/",
+                url: "https://cn-jiangsu.api-ipw.wsmdn.top/"
             },
             {
                 label: "中国 广东 深圳 龙岗 坪地街道 中国移动",
                 id: "cn-shenzhen",
-                url :"https://cn-shenzhen.api-ipw.wsmdn.top/",
+                url: "https://cn-shenzhen.api-ipw.wsmdn.top/"
             },
-            // IP 直连新节点：URL 留空，仅经独立中间件转发
+            {
+                label: "中国 湖北 武汉 电信",
+                id: "cn-wuhan-chinatelecom",
+                url: ""
+            },
+            // IP 直连的节点：URL 留空，仅经独立中间件转发
             {
                 label: "上海 腾讯云 BGP",
                 id: "tencent-sh",
-                url :"",
-            },
-        ],
-        IPv4: [
-            {
-                label: "中国 广东 广州 腾讯云",
-                id: "cn-guangzhou",
-                url :"https://cn-guangzhou.api-ipw.wsmdn.top/",
-            },
-            {
-                label: "新加坡 腾讯云",
-                id: "sg-1",
-                url :"https://sg-1.api-ipw.wsmdn.top/",
-            },
-            {
-                label: "中国 香港 新界 西贡区 将军澳 MICC[ZFC]",
-                id: "hk-shatin",
-                url :"https://china-hk-kowloon-shatindistrict-newcloud.ipwapi.zfap.wsmdn.top/",
-            },
-            {
-                label: "中国 陕西 西安 北经济技术开发区 未央区凤城 中国电信[ZFC]",
-                id: "cn-xian",
-                url :"https://cn-xian-shaanxiprovince.api-ipw.wsmdn.top/",
-            },
-            {
-                label: "美国/加利福尼亚州/洛杉矶/蒙特雷帕克/USCD[ZFC]",
-                id: "us-la",
-                url :"https://america-california-losangeles.ipwapi.zfap.wsmdn.top/",
-            },
-            // IP 直连新节点：URL 留空，仅经独立中间件转发
-            {
-                label: "山东 枣庄 双线",
-                id: "zaozhuang",
-                url :"",
-            },
-            {
-                label: "湖北 十堰 电信",
-                id: "shiyan",
-                url :"",
-            },
-            {
-                label: "香港 VpsQuan",
-                id: "hongkong2",
-                url :"",
-            },
-            {
-                label: "北京 京东云 BGP",
-                id: "jdcloud",
-                url :"",
-            },
-            {
-                label: "陕西 西安二 电信",
-                id: "xian2",
-                url :"",
-            },
-            {
-                label: "香港 Cogent",
-                id: "hongkong",
-                url :"",
-            }
-        ],
-        IPv6: [
-            {
-                label: "中国 四川 沙渠 电信[ZFC]",
-                id: "cn2-sichuan",
-                url:"https://cn2-sichuan.api-ipw.wsmdn.top/",
-            },
-            {
-                label: "中国 香港 九龙城区 旺角东 Cloudie[ZFC]",
-                id: "lntl-cn-hk-kowloon",
-                url:"https://lntl-cn-hk-kowloon.api-ipw.wsmdn.top/",
-            },
-            {
-                label: "中国 河北 秦皇岛 联通",
-                id: "cn-hebei-qinhuangdao",
-                url :"https://cn-hebei-qinhuangdao.api-ipw.wsmdn.top/",
+                url: ""
             }
         ]
-    },
-    NSLookup:[
-        {
-            label: "中国 江苏 移动",
-            id: "cn-jiangsu",
-            url :"https://cn-jiangsu.api-ipw.wsmdn.top/",
-        },
-        {
-            label: "中国 广州 腾讯云",
-            id: "cn-guangzhou",
-            url :"https://cn-guangzhou.api-ipw.wsmdn.top/",
-        },
-        {
-            label: "新加坡 腾讯云",
-            id: "sg-1",
-            url :"https://sg-1.api-ipw.wsmdn.top/",
-        },
-        {
-            label: "中国 四川 沙渠 电信[ZFC]",
-            id: "cn2-sichuan",
-            url:"https://cn2-sichuan.api-ipw.wsmdn.top/",
-        },
-        {
-            label: "中国 陕西 西安 北经济技术开发区 未央区凤城 中国电信[ZFC]",
-            id: "cn-xian",
-            url :"https://cn-xian-shaanxiprovince.api-ipw.wsmdn.top/",
-        },
-        {
-            label: "中国 香港 新界 西贡区 将军澳 MICC[ZFC]",
-            id: "hk-shatin",
-            url :"https://china-hk-kowloon-shatindistrict-newcloud.ipwapi.zfap.wsmdn.top/",
-        },
-        {
-            label: "中国 香港 九龙城区 旺角东 Cloudie[ZFC]",
-            id: "lntl-cn-hk-kowloon",
-            url:"https://lntl-cn-hk-kowloon.api-ipw.wsmdn.top/",
-        },
-        {
-            label: "中国 广东 深圳 龙岗 坪地街道 中国移动",
-            id: "cn-shenzhen",
-            url :"https://cn-shenzhen.api-ipw.wsmdn.top/",
-        },
-        {
-            label: "美国/加利福尼亚州/洛杉矶/蒙特雷帕克/USCD[ZFC]",
-            id: "us-la",
-            url :"https://america-california-losangeles.ipwapi.zfap.wsmdn.top/",
-        },
-        // IP 直连新节点：URL 留空，仅经独立中间件转发
-        {
-            label: "上海 腾讯云 BGP",
-            id: "tencent-sh",
-            url :"",
-        },
-        {
-            label: "山东 枣庄 双线",
-            id: "zaozhuang",
-            url :"",
-        },
-        {
-            label: "湖北 十堰 电信",
-            id: "shiyan",
-            url :"",
-        },
-        {
-            label: "香港 VpsQuan",
-            id: "hongkong2",
-            url :"",
-        },
-        {
-            label: "北京 京东云 BGP",
-            id: "jdcloud",
-            url :"",
-        },
-        {
-            label: "陕西 西安二 电信",
-            id: "xian2",
-            url :"",
-        },
-        {
-            label: "香港 Cogent",
-            id: "hongkong",
-            url :"",
-        },
-        {
-            label: "中国 河北 秦皇岛 联通",
-            id: "cn-hebei-qinhuangdao",
-            url :"https://cn-hebei-qinhuangdao.api-ipw.wsmdn.top/",
-        }
-    ]
+    }
 }
 export { config }

frontend-ssr/server/api/whois/[domain].get.ts

@@ -1,6 +1,9 @@
 import { defineEventHandler, createError } from 'h3'
 
 const IANA_BOOTSTRAP_URL = 'https://data.iana.org/rdap/dns.json'
+// bootstrap 数据基本不变，按进程缓存 24h，避免每个请求都重新下载
+const BOOTSTRAP_TTL = 24 * 60 * 60 * 1000
+let bootstrapCache: { map: Map<string, string>; at: number } | null = null
 
 function encodeDomain(input: string): string {
   try {
@@ -21,8 +24,12 @@ function getTLDCandidates(hostname: string): string[] {
 }
 
 async function fetchBootstrap(): Promise<Map<string, string>> {
+  if (bootstrapCache && Date.now() - bootstrapCache.at < BOOTSTRAP_TTL) {
+    return bootstrapCache.map
+  }
   const res = await fetch(IANA_BOOTSTRAP_URL, {
     headers: { accept: 'application/json' },
+    signal: AbortSignal.timeout(10_000),
   })
   if (!res.ok) {
     throw createError({
@@ -42,6 +49,7 @@ async function fetchBootstrap(): Promise<Map<string, string>> {
       map.set(String(tld), baseUrl)
     }
   }
+  bootstrapCache = { map, at: Date.now() }
   return map
 }
 
@@ -214,6 +222,7 @@ export default defineEventHandler(async (event) => {
 
   const primaryRes = await fetch(rdapUrl, {
     headers: { accept: 'application/rdap+json' },
+    signal: AbortSignal.timeout(15_000),
   })
 
   if (!primaryRes.ok) {
@@ -233,6 +242,7 @@ export default defineEventHandler(async (event) => {
     try {
       const thickRes = await fetch(relatedLink.href, {
         headers: { accept: 'application/rdap+json' },
+        signal: AbortSignal.timeout(15_000),
       })
       if (thickRes.ok) {
         thickData = await thickRes.json()

frontend-ssr/server/routes/ip/[ip].get.ts

@@ -0,0 +1,149 @@
+import { defineEventHandler, createError, setResponseStatus, setResponseHeader, getRequestHeader, getRequestIP } from 'h3'
+import { config } from '../../../config/index'
+import { useMiddlewareFetch } from '../../../utils/middleware'
+
+// GET /ip/<ip> → text/plain 输出指定 IP 的归属地（支持 IPv4 / IPv6，如 /ip/2001:db8::1）
+//
+//   IP: 2001:db8::1
+//   bilibili: 中国 江苏 南京 电信
+//   geocn: 江苏省 南京市 江宁区 电信 宽带
+//   ip2region: 中国 江苏 南京 电信
+//   maxmind_city: 中国 江苏 南京
+//   maxmind_asn: AS4134 中国电信
+//   qqwry: 中国 江苏省 南京市 电信
+//
+// 复用 utils/middleware.ts 的 useMiddlewareFetch()：候选依次为 config.Middleware 外部中间层 + 前端自带中间件兜底，
+// 仅当节点无法连接或上游 401/403/418/502 时切换；IPLocationAPI 配置了多个后端时逐个重试。
+
+// ---- 简单限流（每 IP 每分钟次数上限，进程内内存计数；limit 0 表示不限流） ----
+const rateLimitMap = new Map<string, { count: number; resetAt: number }>()
+
+function checkRateLimit(ip: string, limit: number): boolean {
+    const now = Date.now()
+    const entry = rateLimitMap.get(ip)
+    if (!entry || entry.resetAt <= now) {
+        rateLimitMap.set(ip, { count: 1, resetAt: now + 60_000 })
+        // 顺带清理过期条目，避免 Map 无限增长
+        if (rateLimitMap.size > 1000) {
+            for (const [k, v] of rateLimitMap) {
+                if (v.resetAt <= now) rateLimitMap.delete(k)
+            }
+        }
+        return true
+    }
+    entry.count++
+    return entry.count <= limit
+}
+
+// ---- 文本美化：把单个数据源的归属地对象拼成可读字符串 ----
+function objectToText(obj: any): string {
+    const parts: string[] = []
+    // 位置字段（按国家 → 省/区域 → 城市 → 区县）
+    for (const k of ['country', 'administrative_area', 'region', 'city', 'district', 'province']) {
+        const v = obj[k]
+        if (typeof v === 'string' && v) parts.push(v)
+    }
+    // ASN 编号（如 "AS4134"）
+    if (typeof obj.asn === 'string' && obj.asn) {
+        parts.push(obj.asn.startsWith('AS') ? obj.asn : `AS${obj.asn}`)
+    }
+    // 运营商 / 组织 / 类型
+    for (const k of ['isp', 'org', 'type']) {
+        const v = obj[k]
+        if (typeof v === 'string' && v) parts.push(v)
+    }
+    return [...new Set(parts)].join(' ')
+}
+
+// ---- 文本美化：多数据源逐行输出（跳过后端未加载的库） ----
+function formatLocationText(data: any, ip: string): string {
+    const lines: string[] = [`IP: ${ip}`]
+    const sources: Array<[string, any]> = [
+        ['bilibili', data?.bilibili],
+        ['geocn', data?.geocn],
+        ['ip2region', data?.ip2region],
+        ['ip2location', data?.ip2location],
+        ['maxmind_city', data?.maxmind_city],
+        ['maxmind_asn', data?.maxmind_asn],
+        ['dbip_city', data?.dbip_city],
+        ['dbip_asn', data?.dbip_asn],
+        ['qqwry', data?.qqwry],
+    ]
+    for (const [name, value] of sources) {
+        if (value === undefined || value === null) continue
+        if (typeof value === 'string') {
+            // 纯字符串结果（error 等）原样输出，"not loaded" 跳过
+            if (value && value !== 'not loaded') {
+                lines.push(`${name}: ${value}`)
+            }
+            continue
+        }
+        if (typeof value === 'object') {
+            const text = objectToText(value)
+            if (text) lines.push(`${name}: ${text}`)
+        }
+    }
+    return lines.join('\n')
+}
+
+// ---- 核心：查询指定 IP 的归属地（IPLocationAPI 多后端逐个重试） ----
+async function locate(event: any, ip: string) {
+    const backends = config.IPLocationAPI
+    if (!backends || backends.length === 0) {
+        throw createError({ statusCode: 500, statusMessage: 'No location backend configured' })
+    }
+    let lastError: any = null
+    for (const backend of backends) {
+        const path = `/middleware/${backend.id}/location/${ip}`
+        const { data, error, execute } = useMiddlewareFetch(path)
+        await execute()
+        if (error.value) {
+            lastError = error.value
+            console.error(`[ip] backend "${backend.label}" failed for ${ip}:`, error.value?.message || error.value)
+            continue
+        }
+        // 成功：location 响应必含 ip 字段；缺失视为失败（如误返回错误体），换下一个后端
+        const res = data.value
+        if (res && typeof res === 'object' && (res as any).ip) {
+            return formatLocationText(res, ip)
+        }
+        lastError = new Error('invalid location response')
+    }
+
+    // 全部后端失败：透传最后一次错误（text/plain）
+    const errStatus = lastError?.status ?? lastError?.statusCode ?? 502
+    const status = typeof errStatus === 'number' ? errStatus : 502
+    setResponseStatus(event, status)
+    return `Error ${status}: ${lastError?.message || 'Backend unreachable'}`
+}
+
+export default defineEventHandler(async (event) => {
+    // 0) 统一输出 text/plain（不是 JSON）
+    setResponseHeader(event, 'content-type', 'text/plain; charset=utf-8')
+
+    // 1) Origin / Referer 校验：跨域浏览器调用一律拒绝
+    const siteOrigin = new URL(config.siteUrl).origin
+    const origin = getRequestHeader(event, 'origin')
+    const referer = getRequestHeader(event, 'referer')
+    if (origin && origin !== siteOrigin) {
+        throw createError({ statusCode: 403, statusMessage: 'Forbidden: cross-origin request' })
+    }
+    if (referer && referer !== siteOrigin && !referer.startsWith(siteOrigin + '/')) {
+        throw createError({ statusCode: 403, statusMessage: 'Forbidden: invalid referer' })
+    }
+
+    // 2) 每 IP 每分钟限流（次数取 config.rateLimitPerMinute，0 表示不限流）
+    const rateLimit = config.rateLimitPerMinute || 0
+    if (rateLimit > 0 && !checkRateLimit(getRequestIP(event) || 'unknown', rateLimit)) {
+        throw createError({ statusCode: 429, statusMessage: 'Too Many Requests' })
+    }
+
+    // 3) 取路径参数 IP
+    const ipParam: string = event.context.params?.ip as any
+    let ip = ipParam ? ipParam.trim() : ''
+    if (!ip) {
+        throw createError({ statusCode: 400, statusMessage: 'Missing IP parameter' })
+    }
+
+    return locate(event, ip)
+})

frontend-ssr/server/routes/ip/index.get.ts

@@ -0,0 +1,153 @@
+import { defineEventHandler, getQuery, createError, setResponseStatus, setResponseHeader, getRequestHeader, getRequestIP } from 'h3'
+import { config } from '../../../config/index'
+import { useMiddlewareFetch } from '../../../utils/middleware'
+
+// GET /ip → text/plain 输出 IP 归属地（?ip=<ip> 优先，否则查请求方 IP）
+//
+//   IP: 1.2.3.4
+//   bilibili: 中国 江苏 南京 电信
+//   geocn: 江苏省 南京市 江宁区 电信 宽带
+//   ip2region: 中国 江苏 南京 电信
+//   maxmind_city: 中国 江苏 南京
+//   maxmind_asn: AS4134 中国电信
+//   qqwry: 中国 江苏省 南京市 电信
+//
+// 复用 utils/middleware.ts 的 useMiddlewareFetch()：候选依次为 config.Middleware 外部中间层 + 前端自带中间件兜底，
+// 仅当节点无法连接或上游 401/403/418/502 时切换；IPLocationAPI 配置了多个后端时逐个重试。
+
+// ---- 简单限流（每 IP 每分钟次数上限，进程内内存计数；limit 0 表示不限流） ----
+const rateLimitMap = new Map<string, { count: number; resetAt: number }>()
+
+function checkRateLimit(ip: string, limit: number): boolean {
+    const now = Date.now()
+    const entry = rateLimitMap.get(ip)
+    if (!entry || entry.resetAt <= now) {
+        rateLimitMap.set(ip, { count: 1, resetAt: now + 60_000 })
+        // 顺带清理过期条目，避免 Map 无限增长
+        if (rateLimitMap.size > 1000) {
+            for (const [k, v] of rateLimitMap) {
+                if (v.resetAt <= now) rateLimitMap.delete(k)
+            }
+        }
+        return true
+    }
+    entry.count++
+    return entry.count <= limit
+}
+
+// ---- 文本美化：把单个数据源的归属地对象拼成可读字符串 ----
+function objectToText(obj: any): string {
+    const parts: string[] = []
+    // 位置字段（按国家 → 省/区域 → 城市 → 区县）
+    for (const k of ['country', 'administrative_area', 'region', 'city', 'district', 'province']) {
+        const v = obj[k]
+        if (typeof v === 'string' && v) parts.push(v)
+    }
+    // ASN 编号（如 "AS4134"）
+    if (typeof obj.asn === 'string' && obj.asn) {
+        parts.push(obj.asn.startsWith('AS') ? obj.asn : `AS${obj.asn}`)
+    }
+    // 运营商 / 组织 / 类型
+    for (const k of ['isp', 'org', 'type']) {
+        const v = obj[k]
+        if (typeof v === 'string' && v) parts.push(v)
+    }
+    return [...new Set(parts)].join(' ')
+}
+
+// ---- 文本美化：多数据源逐行输出（跳过后端未加载的库） ----
+function formatLocationText(data: any, ip: string): string {
+    const lines: string[] = [`IP: ${ip}`]
+    const sources: Array<[string, any]> = [
+        ['bilibili', data?.bilibili],
+        ['geocn', data?.geocn],
+        ['ip2region', data?.ip2region],
+        ['ip2location', data?.ip2location],
+        ['maxmind_city', data?.maxmind_city],
+        ['maxmind_asn', data?.maxmind_asn],
+        ['dbip_city', data?.dbip_city],
+        ['dbip_asn', data?.dbip_asn],
+        ['qqwry', data?.qqwry],
+    ]
+    for (const [name, value] of sources) {
+        if (value === undefined || value === null) continue
+        if (typeof value === 'string') {
+            // 纯字符串结果（error 等）原样输出，"not loaded" 跳过
+            if (value && value !== 'not loaded') {
+                lines.push(`${name}: ${value}`)
+            }
+            continue
+        }
+        if (typeof value === 'object') {
+            const text = objectToText(value)
+            if (text) lines.push(`${name}: ${text}`)
+        }
+    }
+    return lines.join('\n')
+}
+
+// ---- 核心：查询指定 IP 的归属地（IPLocationAPI 多后端逐个重试） ----
+async function locate(event: any, ip: string) {
+    const backends = config.IPLocationAPI
+    if (!backends || backends.length === 0) {
+        throw createError({ statusCode: 500, statusMessage: 'No location backend configured' })
+    }
+    let lastError: any = null
+    for (const backend of backends) {
+        const path = `/middleware/${backend.id}/location/${ip}`
+        const { data, error, execute } = useMiddlewareFetch(path)
+        await execute()
+        if (error.value) {
+            lastError = error.value
+            console.error(`[ip] backend "${backend.label}" failed for ${ip}:`, error.value?.message || error.value)
+            continue
+        }
+        // 成功：location 响应必含 ip 字段；缺失视为失败（如误返回错误体），换下一个后端
+        const res = data.value
+        if (res && typeof res === 'object' && (res as any).ip) {
+            return formatLocationText(res, ip)
+        }
+        lastError = new Error('invalid location response')
+    }
+
+    // 全部后端失败：透传最后一次错误（text/plain）
+    const errStatus = lastError?.status ?? lastError?.statusCode ?? 502
+    const status = typeof errStatus === 'number' ? errStatus : 502
+    setResponseStatus(event, status)
+    return `Error ${status}: ${lastError?.message || 'Backend unreachable'}`
+}
+
+export default defineEventHandler(async (event) => {
+    // 0) 统一输出 text/plain（不是 JSON）
+    setResponseHeader(event, 'content-type', 'text/plain; charset=utf-8')
+
+    // 1) Origin / Referer 校验：跨域浏览器调用一律拒绝
+    const siteOrigin = new URL(config.siteUrl).origin
+    const origin = getRequestHeader(event, 'origin')
+    const referer = getRequestHeader(event, 'referer')
+    if (origin && origin !== siteOrigin) {
+        throw createError({ statusCode: 403, statusMessage: 'Forbidden: cross-origin request' })
+    }
+    if (referer && referer !== siteOrigin && !referer.startsWith(siteOrigin + '/')) {
+        throw createError({ statusCode: 403, statusMessage: 'Forbidden: invalid referer' })
+    }
+
+    // 2) 每 IP 每分钟限流（次数取 config.rateLimitPerMinute，0 表示不限流）
+    const rateLimit = config.rateLimitPerMinute || 0
+    if (rateLimit > 0 && !checkRateLimit(getRequestIP(event) || 'unknown', rateLimit)) {
+        throw createError({ statusCode: 429, statusMessage: 'Too Many Requests' })
+    }
+
+    // 3) 确定要查询的 IP：?ip=<ip> 优先，否则查请求方 IP
+    const query = getQuery(event)
+    let ip = typeof query.ip === 'string' ? query.ip.trim() : ''
+    if (!ip) {
+        ip = getRequestIP(event, { xForwardedFor: true }) || ''
+    }
+    ip = ip.trim()
+    if (!ip) {
+        throw createError({ statusCode: 400, statusMessage: 'Unable to determine IP address' })
+    }
+
+    return locate(event, ip)
+})

frontend-ssr/server/routes/middleware/[...slug].get.ts

@@ -21,6 +21,8 @@ function checkRateLimit(ip: string, limit: number): boolean {
     return entry.count <= limit
 }
 
+// 数据上报已移除：统计与拨测明细统一由下游节点（lemon-ipw/src）自行上报，
+// 本转发入口不再计数、不再 POST /report，转发请求也不再携带 X-Boce-Reporter 归属头（防双算协议已废除）。
 export default defineEventHandler(async (event) => {
     // 1) Origin / Referer 校验：跨域浏览器调用一律拒绝。
     //    注意：无 Origin/Referer 的服务端 SSR 调用与命令行请求无法区分，仅靠下方限流约束。
@@ -71,10 +73,15 @@ export default defineEventHandler(async (event) => {
     if (!backendID || !apiType || !raw) {
         throw createError({ statusCode: 400, statusMessage: 'Missing parameters in slug' })
     }
+    // 阻断路径穿越：raw 里的 ".." 会被上游 URL 规范化解析掉，
+    // 把请求（连同节点的 Authorization 头）带到 /v1 之外的任意路径
+    if (raw.split('/').some(seg => seg === '.' || seg === '..')) {
+        throw createError({ statusCode: 400, statusMessage: 'Invalid path' })
+    }
     const query = getQuery(event)
+    const runtimeConfig = useRuntimeConfig(event)
 
     // 从运行时变量读取 APIKEYS (JSON字符串)，解析后按 backendID 查找 token
-    const runtimeConfig = useRuntimeConfig(event)
     let apiKey: string | undefined
     try {
         const apiKeysMap: Record<string, string> = (runtimeConfig.apiKeys || {}) as Record<string, string>
@@ -85,7 +92,7 @@ export default defineEventHandler(async (event) => {
     } catch (e) {
         console.debug('[middleware debug] JSON parse FAILED:', e)
     }
-    // 转发头：不透传 Origin，避免上游 CORS 误判；仅按需注入 Authorization
+    // 转发头：不透传 Origin，避免上游 CORS 误判；仅按需注入 Authorization。
     const authHeaders: Record<string, string> = {}
     if (apiKey) {
         authHeaders['Authorization'] = `Bearer ${apiKey}`
@@ -93,30 +100,21 @@ export default defineEventHandler(async (event) => {
     } else {
         console.debug('[middleware debug] authHeaders NO Authorization header')
     }
-    
     if (apiType === 'whois' || apiType === 'dns' || apiType === 'location' || apiType === 'ssl' || apiType === 'asn' || apiType === 'dnssec' || apiType === 'detail') {
         let apiBaseUrls: Array<{ id: string, url: string ,label: string}> = []
         switch (apiType) {
             case 'whois':
-                apiBaseUrls = [...config.apiBaseUrls]
+            case 'ssl':
+            case 'detail':
+                apiBaseUrls = [...config.APIBaseURL.DualStack]
                 break
             case 'dns':
-                apiBaseUrls = [...config.NSLookup]
+            case 'dnssec':
+                apiBaseUrls = [...config.APIBaseURL.DualStack, ...config.APIBaseURL.IPv4, ...config.APIBaseURL.IPv6]
                 break
             case 'location':
-                apiBaseUrls = [...config.IPLocationAPIs]
-                break
-            case 'ssl':
-                apiBaseUrls = [...config.apiBaseUrls]
-                break
             case 'asn':
-                apiBaseUrls = [...config.IPLocationAPIs]
-                break
-            case 'dnssec':
-                apiBaseUrls = [...config.NSLookup]
-                break
-            case 'detail':
-                apiBaseUrls = [...config.apiBaseUrls]
+                apiBaseUrls = [...config.IPLocationAPI]
                 break
             default:
                 throw createError({ statusCode: 400, statusMessage: 'Invalid API type' })
@@ -126,8 +124,9 @@ export default defineEventHandler(async (event) => {
             throw createError({ statusCode: 400, statusMessage: 'Invalid backend ID' })
         }
         let apiBaseUrl = map.get(backendID)
-        if (apiBaseUrl === undefined) {
-            throw createError({ statusCode: 400, statusMessage: 'API base URL not found for the given backend ID' })
+        // url 为空的节点无法转发（会变成对前端自身的请求），直接报 502 而不是浪费一次自请求
+        if (!apiBaseUrl) {
+            throw createError({ statusCode: 502, statusMessage: 'Backend URL not configured' })
         }
         let data: any = {}
 
@@ -137,6 +136,7 @@ export default defineEventHandler(async (event) => {
             data = await $fetch(`${apiBaseUrl}v1/${apiType}/${raw}`, {
                 method: 'GET',
                 headers: authHeaders,
+                timeout: 15_000,
             }).catch((error: any) => {
                 console.error(`Error fetching from ${apiBaseUrl}:`, error)
                 const errStatus = error?.status ?? error?.statusCode
@@ -151,28 +151,19 @@ export default defineEventHandler(async (event) => {
             })
         return data
     }else if (apiType === 'tcping' || apiType === 'udping' || apiType === 'speed') {
-        let apiBaseUrls:Array<{ id: string, url: string ,label: string}> = []
-        let apiTypeConfig: any = {}
-        switch (apiType) {
-            case 'tcping':
-                apiTypeConfig = config.TCPing
-                apiBaseUrls = [...apiTypeConfig.DualStack, ...apiTypeConfig.IPv4, ...apiTypeConfig.IPv6]
-                break
-            case 'speed':
-                apiTypeConfig = config.SpeedTest
-                apiBaseUrls = [...apiTypeConfig.DualStack, ...apiTypeConfig.IPv4, ...apiTypeConfig.IPv6]
-                break
-            default:
-                throw createError({ statusCode: 400, statusMessage: 'Invalid API type' })
-
-        }
+        // tcping/udping/speed 统一走 APIBaseURL 节点池（平铺三栈）
+        const apiBaseUrls: Array<{ id: string, url: string ,label: string}> = [
+            ...config.APIBaseURL.DualStack,
+            ...config.APIBaseURL.IPv4,
+            ...config.APIBaseURL.IPv6
+        ]
         const map = new Map<string, string>(apiBaseUrls.map(api => [api.id, api.url]))
         if (!map.has(backendID)) {
             throw createError({ statusCode: 400, statusMessage: 'Invalid backend ID' })
         }
         let apiBaseUrl = map.get(backendID)
-        if (apiBaseUrl === undefined) {
-            throw createError({ statusCode: 400, statusMessage: 'API base URL not found for the given backend ID' })
+        if (!apiBaseUrl) {
+            throw createError({ statusCode: 502, statusMessage: 'Backend URL not configured' })
         }
         let data: any = {}
 
@@ -187,6 +178,7 @@ export default defineEventHandler(async (event) => {
         data = await $fetch(`${apiBaseUrl}v1/${apiType}/${raw}${queryString ? '?' + queryString : ''}`, {
                 method: 'GET',
                 headers: authHeaders,
+                timeout: 30_000, // tcping/测速上游本身较慢，给更长超时
             }).catch((error: any) => {
                 console.error(`Error fetching from ${apiBaseUrl}:`, error)
                 const errStatus = error?.status ?? error?.statusCode

frontend-ssr/utils/middleware.ts

@@ -64,9 +64,12 @@ export function useMiddlewareFetch<T = any>(url: MaybeRefOrGetter<string>, optio
         try {
             for (let i = 0; i < candidates.value.length; i++) {
                 if (id !== requestId) return undefined // 已被更新的请求取代
+                const candidate = candidates.value[i]
+                // noUncheckedIndexedAccess 下索引访问为 string | undefined，防御性跳过
+                if (candidate === undefined) continue
                 try {
                     // $fetch 为 Nuxt 全局注入；候选失败会抛 FetchError（含 status）
-                    const res = await $fetch<T>(candidates.value[i], fetchOptions)
+                    const res = await $fetch<T>(candidate, fetchOptions)
                     if (id !== requestId) return undefined
                     data.value = res
                     return res

frontend-ssr/utils/tools.ts

@@ -5,21 +5,21 @@ export function extractHost(url: string): string {
   return match?.groups?.host ?? url;
 }
 
-export function formatTime(ms: number): string {
-  if (ms == null || ms <= 0) return '-'
+export function formatTime(ms?: number | null): string {
+  if (ms == null || typeof ms !== 'number' || !isFinite(ms) || ms <= 0) return '-'
   if (ms < 1000) {
     return `${ms.toFixed(2)} ms`
   }
   return `${(ms / 1000).toFixed(2)} s`
 }
 
-export function formatSpeed(speed: number): string {
-  if (speed == null) return '-'
+export function formatSpeed(speed?: number | null): string {
+  if (speed == null || typeof speed !== 'number' || !isFinite(speed)) return '-'
   return `${speed.toFixed(2)} KB/s`
 }
 
-export function formatSize(bytes: number): string {
-  if (bytes == null) return '-'
+export function formatSize(bytes?: number | null): string {
+  if (bytes == null || typeof bytes !== 'number' || !isFinite(bytes)) return '-'
   if (bytes < 1024) {
     return `${bytes} B`
   }
@@ -29,7 +29,8 @@ export function formatSize(bytes: number): string {
   return `${(bytes / 1024 / 1024).toFixed(2)} MB`
 }
 
-export function getStatusCodeClass(code: number): string {
+export function getStatusCodeClass(code?: number | null): string {
+  if (code == null || typeof code !== 'number') return 'status-error'
   if (code >= 200 && code < 300) return 'status-success'
   if (code >= 300 && code < 400) return 'status-warning'
   return 'status-error'

install.sh

@@ -76,14 +76,14 @@ PORTS=${PORTS:-8080}
 
 read -r -p "单栈模式 SINGLE_STACK（留空=双栈，ipv4 或 ipv6）: " SINGLE_STACK
 
-read -r -p "访问令牌 access_token（留空=不启用鉴权）: " ACCESS_TOKEN
+read -r -p "访问令牌 access-token（留空=不启用鉴权）: " ACCESS_TOKEN
 
 read -r -p "DNS 服务器 [119.28.28.28:53]（主从逗号分隔，如 119.28.28.28:53,223.5.5.5:53）: " DNS_SERVER
 DNS_SERVER=${DNS_SERVER:-119.28.28.28:53}
 
 read -r -p "DNSSEC 专用 DNS（留空=沿用上面 dns-server）: " DNSSEC_DNS_SERVER
 
-read -r -p "启用 IP 数据库 ipdb（首次启动下载约 200MB）[Y/n]: " IPDB_CHOICE
+read -r -p "启用 IP 数据库 ipdb（首次启动下载约 450MB）[Y/n]: " IPDB_CHOICE
 case "${IPDB_CHOICE,,}" in
     n|no) IPDB="false" ;;
     *)    IPDB="true" ;;
@@ -102,15 +102,18 @@ NODE_KEY=""
 WS_USED_DEFAULT=""
 case "${WS_CHOICE,,}" in
     y|yes)
-        read -r -p "  中间件 WS 完整地址（含 wss:// 前缀与 /ws 路径，如 wss://host:8092/ws；留空=默认 wss://middleware-1.api-ipw.wsmdn.top/ws；逗号分隔可多备）: " WS_URL
+        read -r -p "  中间件 WS 完整地址（含 wss:// 前缀与 /ws 路径，如 wss://host:8092/ws；留空=贡献节点给柠檬 wss://middleware-1.api-ipw.wsmdn.top/ws；逗号分隔多个将同时连接全部）: " WS_URL
         if [ -z "$WS_URL" ]; then
             WS_URL="wss://middleware-1.api-ipw.wsmdn.top/ws"
             WS_USED_DEFAULT="true"
         fi
-        NODE_ID=$(gen_uuid)
-        echo "  节点 id（自动生成 UUID）: $NODE_ID"
+        read -r -p "  节点 id（回车自动生成 UUID）: " NODE_ID
+        if [ -z "$NODE_ID" ]; then
+            NODE_ID=$(gen_uuid)
+            echo "  节点 id（自动生成 UUID）: $NODE_ID"
+        fi
         while [ -z "$NODE_KEY" ]; do
-            read -r -p "  注册 key（必填，中间件 apiKeys 必须包含此节点，否则注册被拒 401）: " NODE_KEY
+            read -r -p "  注册 key（必填，中间件 ws-keys 必须包含此节点，否则注册被拒 401）: " NODE_KEY
             if [ -z "$NODE_KEY" ]; then
                 echo "  错误：不加 key 禁止启用 WS，必须提供注册 key"
             fi
@@ -118,6 +121,14 @@ case "${WS_CHOICE,,}" in
         ;;
 esac
 
+echo ""
+echo "--- OTA 自更新（可选）---"
+read -r -p "启用 OTA 自动升级（跟随 GitHub Release，major 版本不自动升）？[y/N]: " OTA_CHOICE
+NODE_OTA=""
+case "${OTA_CHOICE,,}" in
+    y|yes) NODE_OTA="true" ;;
+esac
+
 echo ""
 echo "--- 其他环境变量（可选）---"
 echo "输入额外的 Environment= 项，每行一个（如 GH_PROXY=https://ghproxy.com/），空行结束："
@@ -142,10 +153,11 @@ echo "安装目录:     $INSTALL_DIR"
 echo "服务名:       lemon-ipw"
 echo "监听端口:     $PORTS"
 echo "单栈模式:     ${SINGLE_STACK:-双栈}"
-echo "access_token: ${ACCESS_TOKEN:+已设置 (隐藏)}"
+echo "access-token: ${ACCESS_TOKEN:+已设置 (隐藏)}"
 echo "DNS:          $DNS_SERVER"
 echo "ipdb:         $IPDB"
-echo "WS 接入:      ${WS_URL:+$WS_URL (id=$NODE_ID, key=${NODE_KEY:+已设置})}${WS_URL:-未启用}"
+echo "WS 接入:      $(if [ -n "$WS_URL" ]; then printf '%s (id=%s, key=%s)' "$WS_URL" "$NODE_ID" "${NODE_KEY:+已设置}"; else printf '未启用'; fi)"
+echo "OTA 自更新:   ${NODE_OTA:-未启用}"
 echo "========================================"
 read -r -p "确认安装？[Y/n]: " CONFIRM
 case "${CONFIRM,,}" in
@@ -173,7 +185,8 @@ echo "下载 $BINARY ..."
 if command -v wget >/dev/null 2>&1; then
     wget -q -O "$INSTALL_DIR/lemonipw" "$DOWNLOAD_URL"
 else
-    curl -sL -o "$INSTALL_DIR/lemonipw" "$DOWNLOAD_URL"
+    # -f 让 404/4xx 直接失败，避免把 GitHub 的 "Not Found" 页面存成二进制
+    curl -fsSL -o "$INSTALL_DIR/lemonipw" "$DOWNLOAD_URL"
 fi
 chmod +x "$INSTALL_DIR/lemonipw"
 echo "二进制已安装到 $INSTALL_DIR/lemonipw"
@@ -182,33 +195,32 @@ echo "二进制已安装到 $INSTALL_DIR/lemonipw"
 SERVICE_FILE="/etc/systemd/system/lemon-ipw.service"
 
 # 收集环境变量（仅非空的写入，避免空值覆盖默认）
+# 值里的双引号/反斜杠需要转义，否则会提前终止 systemd 的引号包裹、损坏 unit
 ENV_LINES=""
-[ -n "$PORTS" ]             && ENV_LINES="${ENV_LINES}Environment=\"PORTS=$PORTS\"
-"
-[ -n "$SINGLE_STACK" ]      && ENV_LINES="${ENV_LINES}Environment=\"SINGLE_STACK=$SINGLE_STACK\"
-"
-[ -n "$ACCESS_TOKEN" ]      && ENV_LINES="${ENV_LINES}Environment=\"ACCESS_TOKEN=$ACCESS_TOKEN\"
-"
-[ -n "$DNS_SERVER" ]        && ENV_LINES="${ENV_LINES}Environment=\"DNS_SERVER=$DNS_SERVER\"
-"
-[ -n "$DNSSEC_DNS_SERVER" ] && ENV_LINES="${ENV_LINES}Environment=\"DNSSEC_DNS_SERVER=$DNSSEC_DNS_SERVER\"
-"
-[ -n "$IPDB" ]              && ENV_LINES="${ENV_LINES}Environment=\"IPDB=$IPDB\"
-"
-[ -n "$CORS" ]              && ENV_LINES="${ENV_LINES}Environment=\"CORS=$CORS\"
-"
-[ -n "$REMOTE_CONFIG_URL" ] && ENV_LINES="${ENV_LINES}Environment=\"REMOTE_CONFIG_URL=$REMOTE_CONFIG_URL\"
-"
-[ -n "$WS_URL" ]            && ENV_LINES="${ENV_LINES}Environment=\"WS_URL=$WS_URL\"
-"
-[ -n "$NODE_ID" ]           && ENV_LINES="${ENV_LINES}Environment=\"NODE_ID=$NODE_ID\"
-"
-[ -n "$NODE_KEY" ]          && ENV_LINES="${ENV_LINES}Environment=\"NODE_KEY=$NODE_KEY\"
+add_env() {
+    local name="$1" value="$2"
+    [ -n "$value" ] || return 0
+    value="${value//\\/\\\\}"
+    value="${value//\"/\\\"}"
+    ENV_LINES="${ENV_LINES}Environment=\"${name}=${value}\"
 "
+}
+add_env PORTS "$PORTS"
+add_env SINGLE_STACK "$SINGLE_STACK"
+add_env ACCESS_TOKEN "$ACCESS_TOKEN"
+add_env DNS_SERVER "$DNS_SERVER"
+add_env DNSSEC_DNS_SERVER "$DNSSEC_DNS_SERVER"
+add_env IPDB "$IPDB"
+add_env CORS "$CORS"
+add_env REMOTE_CONFIG_URL "$REMOTE_CONFIG_URL"
+add_env WS_URL "$WS_URL"
+add_env NODE_ID "$NODE_ID"
+add_env NODE_KEY "$NODE_KEY"
+add_env NODE_OTA "$NODE_OTA"
 if [ -n "$EXTRA_ENVS" ]; then
     while IFS= read -r line; do
-        [ -n "$line" ] && ENV_LINES="${ENV_LINES}Environment=\"$line\"
-"
+        [ -n "$line" ] || continue
+        add_env "${line%%=*}" "${line#*=}"
     done <<< "$EXTRA_ENVS"
 fi
 
@@ -221,8 +233,8 @@ Wants=network-online.target
 [Service]
 Type=simple
 User=root
-WorkingDirectory=$INSTALL_DIR
-ExecStart=$INSTALL_DIR/lemonipw
+WorkingDirectory="${INSTALL_DIR}"
+ExecStart="${INSTALL_DIR}/lemonipw"
 ${ENV_LINES}Restart=always
 RestartSec=5
 
@@ -234,7 +246,9 @@ echo "已生成服务文件 $SERVICE_FILE"
 
 # ---------- 启动服务 ----------
 systemctl daemon-reload
-systemctl enable --now lemon-ipw
+# restart 而非 enable --now：重跑安装改配置后旧进程必须重启才会生效
+systemctl enable lemon-ipw
+systemctl restart lemon-ipw
 systemctl status lemon-ipw --no-pager | head -15
 
 echo ""
@@ -248,7 +262,7 @@ echo "  systemctl restart lemon-ipw     # 重启（改配置后）"
 echo "验证：curl http://127.0.0.1:$PORTS/ 应返回 {\"status\":\"ok\"}"
 if [ -n "$WS_URL" ]; then
     echo ""
-    echo "WS 通道已启用，请把节点注册信息加入中间件 setting.json 的 apiKeys："
+    echo "WS 通道已启用，请把节点注册信息加入中间件 setting.json 的 ws-keys："
     echo "  \"$NODE_ID\": \"$NODE_KEY\""
 fi
 if [ -n "$WS_USED_DEFAULT" ]; then
@@ -260,7 +274,7 @@ if [ -n "$WS_USED_DEFAULT" ]; then
     echo "  WS 地址:      $WS_URL"
     echo "  监听端口:     $PORTS"
     echo "  单栈模式:     ${SINGLE_STACK:-双栈}"
-    echo "  access_token: ${ACCESS_TOKEN:+已设置 (隐藏)}"
+    echo "  access-token: ${ACCESS_TOKEN:+已设置 (隐藏)}"
     echo "  CORS:         ${CORS:-不限}"
     echo "  地区-运营商    请自行填写"
     echo "========================================"

middleware-go/Dockerfile

@@ -1,13 +1,25 @@
-FROM golang:1.26-alpine AS build
+# 多架构构建：buildx 会注入 TARGETOS/TARGETARCH，构建阶段固定在构建机原生平台
+# （--platform=$BUILDPLATFORM）交叉编译，目标架构无需 QEMU 模拟；未用 buildx 时
+# TARGETOS/TARGETARCH 为空，Go 默认取宿主机平台，普通 docker build 仍然可用
+FROM --platform=$BUILDPLATFORM golang:1.26-alpine AS build
+ARG TARGETOS
+ARG TARGETARCH
+ARG TARGETVARIANT
 ENV GO111MODULE=on \
     CGO_ENABLED=0 \
-    GOOS=linux \
-    GOARCH=amd64
+    GOOS=${TARGETOS} \
+    GOARCH=${TARGETARCH}
 WORKDIR /app
 COPY go.mod go.sum ./
 RUN go mod download
-COPY main.go ./
-RUN go build -o main .
+COPY *.go ./
+# TARGETVARIANT 是 buildx 的 "v7"/"v6" 写法，Go 的 GOARM 只要数字；不映射时 GOARCH=arm 默认按 GOARM=6 编译
+RUN set -eux; \
+    case "$TARGETVARIANT" in \
+      v7) export GOARM=7 ;; \
+      v6) export GOARM=6 ;; \
+    esac; \
+    go build -o main .
 
 # 运行阶段
 FROM alpine:latest

middleware-go/main.go

@@ -8,8 +8,10 @@ import (
 	"net/http"
 	"net/url"
 	"os"
+	"runtime"
 	"strconv"
 	"strings"
+	"sync/atomic"
 	"time"
 
 	"github.com/spf13/viper"
@@ -21,7 +23,7 @@ import (
 
 // ==================== 全局变量 ====================
 
-// apiInfo 对应 setting.json apiBaseUrls 等数组中的 { label, id, url } 配置项
+// apiInfo 对应 setting.json 节点池中的 { label, id, url } 配置项
 type apiInfo struct {
 	Label string `json:"label"`
 	ID    string `json:"id"`
@@ -49,7 +51,7 @@ func (w *wsFlag) UnmarshalJSON(b []byte) error {
 // UseWS 判断该节点是否走 WS 通道
 func (a *apiInfo) UseWS() bool { return a != nil && bool(a.WS) }
 
-// stackConfig 对应 setting.json TCPing / SpeedTest
+// stackConfig 对应节点池中的 { DualStack, IPv4, IPv6 } 三栈
 type stackConfig struct {
 	DualStack []apiInfo `json:"DualStack"`
 	IPv4      []apiInfo `json:"IPv4"`
@@ -57,20 +59,24 @@ type stackConfig struct {
 }
 
 // middlewareConfig 仅用于解析 setting.json（JSON 键名统一用连接线，如 http-timeout-seconds）
+// 节点池结构：APIBaseURL 含 {IPv6,IPv4,DualStack} 三栈；IPLocationAPI 为纯数组（无栈区分）。
+// 原 apiBaseUrls/whois·ssl·detail、NSLookup/dns·dnssec、TCPing、SpeedTest 统一并入 APIBaseURL，
+// 原 IPLocationAPI/location·asn 并入 IPLocationAPI。
 type middlewareConfig struct {
 	Port               stringOrNumber    `json:"port"`
 	HTTPTimeoutSeconds int               `json:"http-timeout-seconds"`
 	RateLimit          *int              `json:"rate-limit"` // 单 IP 每分钟限流次数；缺省=默认120，0=不限流
-	WSPort             stringOrNumber   `json:"ws-port"`    // WS 服务端口：兼容 "8092" 与 8092；缺省=8092，"0"/0=关闭 WS 通道
+	WSPort             stringOrNumber    `json:"ws-port"`    // WS 端口：兼容 "8092" 与 8092；缺省=8092，"0"/0=关闭 WS 通道
 	RemoteConfigURL    string            `json:"remote-config-url"`
-	RemoteIngoreConfig []string          `json:"remote-ingore-config"` // 不被远端覆盖的配置项列表
+	RemoteIgnoreConfig []string          `json:"remote-ignore-config"` // 不被远端覆盖的配置项列表
 	Cors               string            `json:"cors"`
-	APIBaseURLs        []apiInfo         `json:"apiBaseUrls"`
-	IPLocationAPIs     []apiInfo         `json:"IPLocationAPIs"`
-	TCPing             stackConfig       `json:"TCPing"`
-	SpeedTest          stackConfig       `json:"SpeedTest"`
-	NSLookup           []apiInfo         `json:"NSLookup"`
-	APIKeys            map[string]string `json:"apiKeys"`
+	TrustedProxies     string            `json:"trusted-proxies"` // 可信代理 IP/CIDR（逗号分隔），c.IP() 仅信任这些来源的 X-Forwarded-For
+	GhProxy            string            `json:"gh-proxy"`        // GitHub 代理前缀（OTA 下载加速），可空
+	Ota                string            `json:"ota"`             // OTA 自更新开关，"true" 启用
+	APIBaseURL         stackConfig       `json:"api-base-url"`    // whois/ssl/detail/dns/dnssec/tcping/speed 上游节点池
+	IPLocationAPI      []apiInfo         `json:"ip-location-api"` // location/asn 上游节点池（纯数组，无栈）
+	APIKeys            map[string]string `json:"api-keys"`        // HTTP 转发鉴权：backendID → token（注入 Authorization: Bearer）
+	WSKeys             map[string]string `json:"ws-keys"`         // WS 注册校验：nodeID → key（节点 register 的 key 须匹配）
 }
 
 // stringOrNumber 兼容 JSON 中的字符串与数字（如 "8080" 或 8080）
@@ -78,23 +84,31 @@ type stringOrNumber string
 
 // 全局配置变量，由 readConfig 从 setting.json 填充
 var (
-	VERSION          string            // 版本号（构建时由 ldflags 注入）
-	COMMIT           string            // 提交哈希（构建时由 ldflags 注入）
-	BUILD_TIME       string            // 构建时间（构建时由 ldflags 注入）
-	PORT             string            // 监听端口
-	HTTP_TIMEOUT     int               // 上游请求超时（秒）
-	CORS             string            // CORS 配置原始字符串（逗号分隔的允许域名，可空）
-	ACCEPT_DOMAINS   []string          // 允许跨域的域名列表（由 CORS 拆分而来，空则允许所有）
-	API_BASE_URLS    []apiInfo         // whois/ssl/detail 上游列表
-	IP_LOCATION_APIS []apiInfo         // location/asn 上游列表
-	TCPING           stackConfig       // tcping 上游列表（DualStack/IPv4/IPv6）
-	SPEED_TEST       stackConfig       // speed 上游列表（DualStack/IPv4/IPv6）
-	NS_LOOKUP        []apiInfo         // dns/dnssec 上游列表
-	API_KEYS         map[string]string // backendID → token
-	CONFIG_SOURCE    string            // 配置文件路径
-	RATE_LIMIT       int               // 单 IP 每分钟限流次数（0 表示不限流），默认 120
-	WS_PORT          int               // WS 服务端口（0 = 关闭），缺省 8092，由 readConfig 统一解析
-	REMOTE_INGORE_CONFIG []string      // 不被远端覆盖的配置项列表（remote-ingore-config / REMOTE_INGORE_CONFIG）
+	VERSION              string            // 版本号（构建时由 ldflags 注入）
+	COMMIT               string            // 提交哈希（构建时由 ldflags 注入）
+	BUILD_TIME           string            // 构建时间（构建时由 ldflags 注入）
+	PORT                 string            // 监听端口
+	HTTP_TIMEOUT         int               // 上游请求超时（秒）
+	CORS                 string            // CORS 配置原始字符串（逗号分隔的允许域名，可空）
+	ACCEPT_DOMAINS       []string          // 允许跨域的域名列表（由 CORS 拆分而来，空则允许所有）
+	API_BASE_URLS        stackConfig       // whois/ssl/detail/dns/dnssec/tcping/speed 上游节点池（DualStack/IPv4/IPv6）
+	IP_LOCATION_APIS     []apiInfo         // location/asn 上游节点池（纯数组，无栈）
+	API_KEYS             map[string]string // backendID → HTTP 转发 token（注入 Authorization: Bearer）
+	WS_KEYS              map[string]string // backendID → WS 注册校验 key
+	CONFIG_SOURCE        string            // 配置文件路径
+	RATE_LIMIT           int               // 单 IP 每分钟限流次数（0 表示不限流），默认 120
+	TRUSTED_PROXIES      string            // 可信代理 IP/CIDR（逗号分隔），供 c.IP() 判定，空 = 不信任 XFF
+	GH_PROXY             string            // GitHub 代理前缀（gh-proxy / GH_PROXY），OTA 下载用，可空
+	OTA                  string            // OTA 自更新开关（ota / OTA），"true" 时启用
+	WS_PORT              int               // WS 服务端口（0 = 关闭），缺省 8092，由 readConfig 统一解析
+	REMOTE_IGNORE_CONFIG []string          // 不被远端覆盖的配置项列表（remote-ignore-config / REMOTE_IGNORE_CONFIG）
+)
+
+// OTA 优雅交接支持（Windows 路径）：见 ota.go
+var (
+	fiberApp           *fiber.App    // 显式持有的 Fiber 应用（gracefulShutdown 需要）
+	otaHandoverWait    chan struct{} // 非 nil 表示 Windows OTA 优雅重启模式：Listen 关闭后 main 停在此等待老进程退出
+	otaShutdownStarted atomic.Bool   // gracefulShutdown 已启动（Listen 退出时区分绑定失败与优雅关闭）
 )
 
 // HTTP_CLIENT 用于转发上游请求（等价于 TS 中的 $fetch），超时由 HTTP_TIMEOUT 决定
@@ -106,6 +120,18 @@ var wsSrv *wsServer
 
 // ==================== 工具函数 ====================
 
+// splitAndTrim 按逗号切分并去掉每段首尾空白与空段（对齐根 main.go 的同名函数）
+func splitAndTrim(s, sep string) []string {
+	parts := strings.Split(s, sep)
+	out := make([]string, 0, len(parts))
+	for _, p := range parts {
+		if p = strings.TrimSpace(p); p != "" {
+			out = append(out, p)
+		}
+	}
+	return out
+}
+
 // envJSON 从环境变量读取 JSON 字符串并反序列化到 target（用于数组/对象等映射表类配置项）。
 // 环境变量为空时不做任何事；解析失败返回错误，避免静默使用空配置。
 func envJSON(key string, target any) error {
@@ -174,6 +200,20 @@ func findNode(list []apiInfo, id string) *apiInfo {
 	return nil
 }
 
+// flattenStack 将节点池三栈展开为一个节点列表（DualStack + IPv4 + IPv6）
+func flattenStack(s stackConfig) []apiInfo {
+	out := make([]apiInfo, 0, len(s.DualStack)+len(s.IPv4)+len(s.IPv6))
+	out = append(out, s.DualStack...)
+	out = append(out, s.IPv4...)
+	out = append(out, s.IPv6...)
+	return out
+}
+
+// stackNonEmpty 判断节点池三栈是否至少有一项
+func stackNonEmpty(s stackConfig) bool {
+	return len(s.DualStack) > 0 || len(s.IPv4) > 0 || len(s.IPv6) > 0
+}
+
 func keysOf(m map[string]string) []string {
 	keys := make([]string, 0, len(m))
 	for k := range m {
@@ -224,12 +264,12 @@ func forwardUpstream(c fiber.Ctx, apiBaseUrl string, target string, headers map[
 }
 
 // lookupAPIKey 查找 backendID 对应的 token。
-// 优先级: setting.json apiKeys > 环境变量 APIKEYS (JSON 字符串)
+// 优先级: setting.json api-keys > 环境变量 API_KEYS (JSON 字符串)
 func lookupAPIKey(backendID string) string {
 	var apiKeys map[string]string
 	if len(API_KEYS) > 0 {
 		apiKeys = API_KEYS
-	} else if raw := os.Getenv("APIKEYS"); raw != "" {
+	} else if raw := os.Getenv("API_KEYS"); raw != "" {
 		if err := json.Unmarshal([]byte(raw), &apiKeys); err != nil {
 			return ""
 		}
@@ -242,6 +282,26 @@ func lookupAPIKey(backendID string) string {
 	return apiKey
 }
 
+// lookupWSKey 查找 nodeID 对应的 WS 注册校验 key。
+// 优先级: setting.json ws-keys > 环境变量 WS_KEYS (JSON 字符串)
+// 与 lookupAPIKey 相互独立：api-keys 用于 HTTP 转发鉴权，ws-keys 用于 WS 注册校验。
+func lookupWSKey(nodeID string) string {
+	var wsKeys map[string]string
+	if len(WS_KEYS) > 0 {
+		wsKeys = WS_KEYS
+	} else if raw := os.Getenv("WS_KEYS"); raw != "" {
+		if err := json.Unmarshal([]byte(raw), &wsKeys); err != nil {
+			return ""
+		}
+	} else {
+		return ""
+	}
+
+	wsKey := wsKeys[nodeID]
+
+	return wsKey
+}
+
 // ==================== 业务接口 ====================
 
 // middlewareHandler 对应前端 server/routes/middleware/[...slug].get.ts
@@ -288,7 +348,7 @@ func middlewareHandler(c fiber.Ctx) error {
 
 	query := c.Queries()
 
-	// 从 API_KEYS 查找 token，未配置时回退到环境变量 APIKEYS (JSON 字符串)
+	// 从 API_KEYS 查找 token，未配置时回退到环境变量 API_KEYS (JSON 字符串)
 	apiKey := lookupAPIKey(backendID)
 
 	// 构造转发给上游的请求头：不透传客户端 Origin，避免上游 CORS 误判
@@ -299,14 +359,13 @@ func middlewareHandler(c fiber.Ctx) error {
 
 	switch apiType {
 	case "whois", "dns", "location", "ssl", "asn", "dnssec", "detail":
+		// 节点池结构：location/asn 走 IPLocationAPI（纯数组，无栈），其余走 APIBaseURL（三栈平铺）
 		var apiBaseUrls []apiInfo
 		switch apiType {
-		case "whois", "ssl", "detail":
-			apiBaseUrls = API_BASE_URLS
-		case "dns", "dnssec":
-			apiBaseUrls = NS_LOOKUP
 		case "location", "asn":
 			apiBaseUrls = IP_LOCATION_APIS
+		default:
+			apiBaseUrls = flattenStack(API_BASE_URLS)
 		}
 
 		node := findNode(apiBaseUrls, backendID)
@@ -314,7 +373,11 @@ func middlewareHandler(c fiber.Ctx) error {
 			return badRequest(c, "Invalid backend ID")
 		}
 		// ws:true 节点：拨测请求经 WS 通道转发（数据上传走 WS），失败返回 502
-		if node.UseWS() && wsSrv != nil {
+		if node.UseWS() {
+			if wsSrv == nil {
+				// 不再静默落回空 URL 的 HTTP 转发（必然 502 且掩盖真实配置错误）
+				return c.Status(fiber.StatusBadGateway).SendString("Node " + backendID + " is WS-only but WS channel is disabled (ws-port=0 or bind failed)")
+			}
 			status, body, err := wsSrv.RequestProbe(backendID, apiType, raw, nil, wsProbeTimeout())
 			if err != nil {
 				return c.Status(fiber.StatusBadGateway).SendString("WS probe failed: " + err.Error())
@@ -331,20 +394,8 @@ func middlewareHandler(c fiber.Ctx) error {
 		return forwardUpstream(c, apiBaseUrl, apiBaseUrl+"v1/"+apiType+"/"+raw, authHeaders, nil)
 
 	case "tcping", "udping", "speed":
-		var apiTypeConfig stackConfig
-		switch apiType {
-		case "tcping":
-			apiTypeConfig = TCPING
-		case "speed":
-			apiTypeConfig = SPEED_TEST
-		default:
-			return badRequest(c, "Invalid API type")
-		}
-
-		apiBaseUrls := make([]apiInfo, 0, len(apiTypeConfig.DualStack)+len(apiTypeConfig.IPv4)+len(apiTypeConfig.IPv6))
-		apiBaseUrls = append(apiBaseUrls, apiTypeConfig.DualStack...)
-		apiBaseUrls = append(apiBaseUrls, apiTypeConfig.IPv4...)
-		apiBaseUrls = append(apiBaseUrls, apiTypeConfig.IPv6...)
+		// tcping/udping/speed 统一走 APIBaseURL 节点池
+		apiBaseUrls := flattenStack(API_BASE_URLS)
 
 		// 转发 query 参数（过滤空值，等价于 TS 中 URLSearchParams 过滤 undefined）
 		queryString := url.Values{}
@@ -361,7 +412,10 @@ func middlewareHandler(c fiber.Ctx) error {
 			return badRequest(c, "Invalid backend ID")
 		}
 		// ws:true 节点：拨测请求经 WS 通道转发
-		if node.UseWS() && wsSrv != nil {
+		if node.UseWS() {
+			if wsSrv == nil {
+				return c.Status(fiber.StatusBadGateway).SendString("Node " + backendID + " is WS-only but WS channel is disabled (ws-port=0 or bind failed)")
+			}
 			status, body, err := wsSrv.RequestProbe(backendID, apiType, raw, queryMap, wsProbeTimeout())
 			if err != nil {
 				return c.Status(fiber.StatusBadGateway).SendString("WS probe failed: " + err.Error())
@@ -398,7 +452,8 @@ func viperValue(key string, target any) error {
 }
 
 // fetchRemoteConfig 从远端 URL 拉取配置内容（middleware setting.json 格式）
-func fetchRemoteConfig(url string) ([]byte, error) {	client := &http.Client{Timeout: 10 * time.Second}
+func fetchRemoteConfig(url string) ([]byte, error) {
+	client := &http.Client{Timeout: 10 * time.Second}
 	resp, err := client.Get(url)
 	if err != nil {
 		return nil, err
@@ -433,7 +488,7 @@ func applyRemoteConfig(mw *middlewareConfig) error {
 	}
 	// ignore 列表：数组中的配置项不被远端覆盖（逐键判断跳过）
 	ignored := func(key string) bool {
-		for _, k := range mw.RemoteIngoreConfig {
+		for _, k := range mw.RemoteIgnoreConfig {
 			if k == key {
 				return true
 			}
@@ -458,22 +513,23 @@ func applyRemoteConfig(mw *middlewareConfig) error {
 	if !ignored("cors") && remote.Cors != "" {
 		mw.Cors = remote.Cors
 	}
-	if !ignored("apiBaseUrls") && len(remote.APIBaseURLs) > 0 {
-		mw.APIBaseURLs = remote.APIBaseURLs
+	if !ignored("trusted-proxies") && remote.TrustedProxies != "" {
+		mw.TrustedProxies = remote.TrustedProxies
 	}
-	if !ignored("IPLocationAPIs") && len(remote.IPLocationAPIs) > 0 {
-		mw.IPLocationAPIs = remote.IPLocationAPIs
+	if !ignored("gh-proxy") && remote.GhProxy != "" {
+		mw.GhProxy = remote.GhProxy
 	}
-	if !ignored("TCPing") && (len(remote.TCPing.DualStack) > 0 || len(remote.TCPing.IPv4) > 0 || len(remote.TCPing.IPv6) > 0) {
-		mw.TCPing = remote.TCPing
+	if !ignored("ota") && remote.Ota != "" {
+		mw.Ota = remote.Ota
 	}
-	if !ignored("SpeedTest") && (len(remote.SpeedTest.DualStack) > 0 || len(remote.SpeedTest.IPv4) > 0 || len(remote.SpeedTest.IPv6) > 0) {
-		mw.SpeedTest = remote.SpeedTest
+	// 节点池结构：api-base-url 与 ip-location-api（远端非空栈时覆盖本地）
+	if !ignored("api-base-url") && stackNonEmpty(remote.APIBaseURL) {
+		mw.APIBaseURL = remote.APIBaseURL
 	}
-	if !ignored("NSLookup") && len(remote.NSLookup) > 0 {
-		mw.NSLookup = remote.NSLookup
+	if !ignored("ip-location-api") && len(remote.IPLocationAPI) > 0 {
+		mw.IPLocationAPI = remote.IPLocationAPI
 	}
-	// apiKeys 强制忽略：密钥凭据不随远端配置覆盖（与后端 access_token 一致），只从本地 setting.json / env 读取
+	// api-keys / ws-keys 强制忽略：密钥凭据不随远端配置覆盖（与后端 access-token 一致），只从本地 setting.json / env 读取
 	log.Printf("[middleware] remote config applied from %s", url)
 	return nil
 }
@@ -520,6 +576,24 @@ func readConfig() error {
 	} else {
 		mw.Cors = viper.GetString("cors")
 	}
+	// trusted-proxies：可信代理 IP/CIDR（逗号分隔），env > setting.json
+	if v := os.Getenv("TRUSTED_PROXIES"); v != "" {
+		mw.TrustedProxies = v
+	} else {
+		mw.TrustedProxies = viper.GetString("trusted-proxies")
+	}
+	// gh-proxy：GitHub 代理前缀（OTA 下载用），env > setting.json
+	if v := os.Getenv("GH_PROXY"); v != "" {
+		mw.GhProxy = v
+	} else {
+		mw.GhProxy = viper.GetString("gh-proxy")
+	}
+	// ota：OTA 自更新开关（"true" 启用），env > setting.json
+	if v := os.Getenv("OTA"); v != "" {
+		mw.Ota = v
+	} else {
+		mw.Ota = viper.GetString("ota")
+	}
 	if v := os.Getenv("REMOTE_CONFIG_URL"); v != "" {
 		mw.RemoteConfigURL = v
 	} else {
@@ -542,64 +616,49 @@ func readConfig() error {
 	} else if viper.IsSet("ws-port") {
 		mw.WSPort = stringOrNumber(viper.GetString("ws-port"))
 	}
-	// remote-ingore-config：不被远端覆盖的配置项列表（env JSON 数组 > setting.json 数组）
-	if raw := os.Getenv("REMOTE_INGORE_CONFIG"); raw != "" {
+	// remote-ignore-config：不被远端覆盖的配置项列表（env JSON 数组 > setting.json 数组）
+	if raw := os.Getenv("REMOTE_IGNORE_CONFIG"); raw != "" {
 		var list []string
 		if err := json.Unmarshal([]byte(raw), &list); err != nil {
-			return fmt.Errorf("parse env REMOTE_INGORE_CONFIG: %w", err)
+			return fmt.Errorf("parse env REMOTE_IGNORE_CONFIG: %w", err)
 		}
-		mw.RemoteIngoreConfig = list
+		mw.RemoteIgnoreConfig = list
 	} else {
-		mw.RemoteIngoreConfig = viper.GetStringSlice("remote-ingore-config")
+		mw.RemoteIgnoreConfig = viper.GetStringSlice("remote-ignore-config")
 	}
 
-	// 数组/对象类配置：先 Getenv（JSON 字符串），再 viper.Get（经 JSON 中转反序列化到 typed 结构）
-	if err := envJSON("API_BASE_URLS", &mw.APIBaseURLs); err != nil {
+	// 节点池结构：api-base-url 与 ip-location-api（env JSON > setting.json）
+	if err := envJSON("API_BASE_URLS", &mw.APIBaseURL); err != nil {
 		return err
 	}
-	if len(mw.APIBaseURLs) == 0 {
-		if err := viperValue("apiBaseUrls", &mw.APIBaseURLs); err != nil {
-			return fmt.Errorf("parse apiBaseUrls: %w", err)
+	if !stackNonEmpty(mw.APIBaseURL) && viper.Get("api-base-url") != nil {
+		if err := viperValue("api-base-url", &mw.APIBaseURL); err != nil {
+			return fmt.Errorf("parse api-base-url: %w", err)
 		}
 	}
-	if err := envJSON("IP_LOCATION_APIS", &mw.IPLocationAPIs); err != nil {
+	if err := envJSON("IP_LOCATION_APIS", &mw.IPLocationAPI); err != nil {
 		return err
 	}
-	if len(mw.IPLocationAPIs) == 0 {
-		if err := viperValue("IPLocationAPIs", &mw.IPLocationAPIs); err != nil {
-			return fmt.Errorf("parse IPLocationAPIs: %w", err)
+	if len(mw.IPLocationAPI) == 0 && viper.Get("ip-location-api") != nil {
+		if err := viperValue("ip-location-api", &mw.IPLocationAPI); err != nil {
+			return fmt.Errorf("parse ip-location-api: %w", err)
 		}
 	}
-	if err := envJSON("TCPING", &mw.TCPing); err != nil {
-		return err
-	}
-	if viper.Get("TCPing") != nil && len(mw.TCPing.DualStack)+len(mw.TCPing.IPv4)+len(mw.TCPing.IPv6) == 0 {
-		if err := viperValue("TCPing", &mw.TCPing); err != nil {
-			return fmt.Errorf("parse TCPing: %w", err)
-		}
-	}
-	if err := envJSON("SPEED_TEST", &mw.SpeedTest); err != nil {
-		return err
-	}
-	if viper.Get("SpeedTest") != nil && len(mw.SpeedTest.DualStack)+len(mw.SpeedTest.IPv4)+len(mw.SpeedTest.IPv6) == 0 {
-		if err := viperValue("SpeedTest", &mw.SpeedTest); err != nil {
-			return fmt.Errorf("parse SpeedTest: %w", err)
-		}
-	}
-	if err := envJSON("NS_LOOKUP", &mw.NSLookup); err != nil {
-		return err
-	}
-	if len(mw.NSLookup) == 0 {
-		if err := viperValue("NSLookup", &mw.NSLookup); err != nil {
-			return fmt.Errorf("parse NSLookup: %w", err)
-		}
-	}
-	if err := envJSON("APIKEYS", &mw.APIKeys); err != nil {
+	if err := envJSON("API_KEYS", &mw.APIKeys); err != nil {
 		return err
 	}
 	if len(mw.APIKeys) == 0 {
-		if err := viperValue("apiKeys", &mw.APIKeys); err != nil {
-			return fmt.Errorf("parse apiKeys: %w", err)
+		if err := viperValue("api-keys", &mw.APIKeys); err != nil {
+			return fmt.Errorf("parse api-keys: %w", err)
+		}
+	}
+	// ws-keys：WS 注册校验表（nodeID → key），优先级 env WS_KEYS > setting.json ws-keys，与 api-keys 相互独立
+	if err := envJSON("WS_KEYS", &mw.WSKeys); err != nil {
+		return err
+	}
+	if len(mw.WSKeys) == 0 {
+		if err := viperValue("ws-keys", &mw.WSKeys); err != nil {
+			return fmt.Errorf("parse ws-keys: %w", err)
 		}
 	}
 
@@ -609,11 +668,8 @@ func readConfig() error {
 	}
 
 	// 校验配置存在（防止在错误的文件上静默空跑）
-	hasEndpoints := len(mw.APIBaseURLs) > 0 || len(mw.NSLookup) > 0 || len(mw.IPLocationAPIs) > 0 ||
-		len(mw.TCPing.DualStack) > 0 || len(mw.TCPing.IPv4) > 0 || len(mw.TCPing.IPv6) > 0 ||
-		len(mw.SpeedTest.DualStack) > 0 || len(mw.SpeedTest.IPv4) > 0 || len(mw.SpeedTest.IPv6) > 0
-	if !hasEndpoints {
-		return fmt.Errorf("invalid config in %s: missing endpoint lists (expected flat middleware config)", path)
+	if !stackNonEmpty(mw.APIBaseURL) && len(mw.IPLocationAPI) == 0 {
+		return fmt.Errorf("invalid config in %s: missing endpoint pools (expected api-base-url / ip-location-api node pools)", path)
 	}
 
 	// 将配置内容写入全局变量
@@ -635,18 +691,20 @@ func readConfig() error {
 		}
 		WS_PORT = n
 	}
-	REMOTE_INGORE_CONFIG = mw.RemoteIngoreConfig
+	REMOTE_IGNORE_CONFIG = mw.RemoteIgnoreConfig
 	CORS = mw.Cors
-	// 逗号分隔的 CORS 域名列表（对齐根 main.go 的 ACCEPT_DOMAINS 用法）
+	// 逗号分隔的 CORS 域名列表（对齐根 main.go 的 ACCEPT_DOMAINS 用法）；
+	// 带空格的配置 "a.com, b.com" 直接 Split 会产生带前导空格的 origin，永远匹配不上，须 trim
 	if CORS != "" {
-		ACCEPT_DOMAINS = strings.Split(CORS, ",")
+		ACCEPT_DOMAINS = splitAndTrim(CORS, ",")
 	}
-	API_BASE_URLS = mw.APIBaseURLs
-	IP_LOCATION_APIS = mw.IPLocationAPIs
-	TCPING = mw.TCPing
-	SPEED_TEST = mw.SpeedTest
-	NS_LOOKUP = mw.NSLookup
+	TRUSTED_PROXIES = mw.TrustedProxies
+	GH_PROXY = mw.GhProxy
+	OTA = mw.Ota
+	API_BASE_URLS = mw.APIBaseURL
+	IP_LOCATION_APIS = mw.IPLocationAPI
 	API_KEYS = mw.APIKeys
+	WS_KEYS = mw.WSKeys
 	CONFIG_SOURCE = viper.ConfigFileUsed()
 	return nil
 }
@@ -670,6 +728,9 @@ func main() {
 	}
 	log.Printf("[middleware] config loaded from %s", CONFIG_SOURCE)
 
+	// OTA 自更新：定期检查 GitHub Release 并替换二进制（配置 ota / OTA 启用）
+	initOTA(GH_PROXY)
+
 	timeout := HTTP_TIMEOUT
 	if timeout <= 0 {
 		timeout = 30
@@ -687,8 +748,24 @@ func main() {
 		log.Printf("[ws] ws channel disabled (wsPort=0)")
 	}
 
-	app := fiber.New()
-
+	// TRUSTED_PROXIES / trusted-proxies：逗号分隔的可信代理 IP/CIDR。配置后 c.IP()（限流按它分桶）
+	// 只信任这些来源转发的 X-Forwarded-For，反代/CDN 后限流才按真实客户端 IP 计数；
+	// 未配置保持默认（不信任 XFF 头）
+	fiberConf := fiber.Config{}
+	if strings.TrimSpace(TRUSTED_PROXIES) != "" {
+		var proxies []string
+		for _, p := range strings.Split(TRUSTED_PROXIES, ",") {
+			if p = strings.TrimSpace(p); p != "" {
+				proxies = append(proxies, p)
+			}
+		}
+		fiberConf.TrustProxy = true
+		fiberConf.TrustProxyConfig = fiber.TrustProxyConfig{Proxies: proxies}
+		fiberConf.ProxyHeader = "X-Forwarded-For"
+		log.Printf("[middleware] trusted proxies: %v", proxies)
+	}
+	fiberApp = fiber.New(fiberConf)
+	app := fiberApp
 	// 单 IP 限流（fiber 内置中间件，默认按客户端 IP 计数）：次数由配置 rateLimit / 环境变量 RATE_LIMIT 决定（默认 120 次/分钟），
 	// 0 表示不限流。必须放在所有路由注册之前，fiber 中间件只对注册在其后的路由生效。
 	if RATE_LIMIT > 0 {
@@ -722,19 +799,35 @@ func main() {
 	app.Get("/v1/*", middlewareHandler)
 	app.Get("/middleware/*", middlewareHandler)
 
-	// 监听地址，优先级: 环境变量 PORT > setting.json port > 默认 8080
-	port := os.Getenv("PORT")
-	if port == "" {
-		port = PORT
+	// 监听地址：readConfig 已按 env PORT > setting.json port 填好全局 PORT，
+	// 这里只在为空时补默认 8080——不要再用 Getenv 覆盖，否则 setting.json 的 port 失效。
+	// waitChildReady 的健康检查地址要用同一个端口
+	if PORT == "" {
+		PORT = "8080"
 	}
-	if port == "" {
-		port = "8080"
-	}
-	listenAddr := port
+	listenAddr := PORT
 	if !strings.Contains(listenAddr, ":") {
 		listenAddr = ":" + listenAddr
 	}
-	if err := app.Listen(listenAddr); err != nil {
-		log.Fatal(err)
+
+	// Windows OTA 优雅交接：Listen 被 gracefulShutdown 关闭后，main 停在停车位，
+	// 由 restartSelf 在新进程健康检查通过后 os.Exit 结束整个老进程
+	if otaEnabled() && runtime.GOOS == "windows" {
+		otaHandoverWait = make(chan struct{})
+	}
+
+	listenErr := make(chan error, 1)
+	go func() { listenErr <- app.Listen(listenAddr) }()
+	err := <-listenErr
+	if err != nil {
+		if otaShutdownStarted.Load() {
+			// 优雅关闭过程中的退出属预期，主流程已在停车位等待交接
+			log.Printf("[ota] listen exited during graceful shutdown: %v", err)
+		} else {
+			log.Fatalf("listen failed: %v", err)
+		}
+	}
+	if otaHandoverWait != nil {
+		<-otaHandoverWait
 	}
 }

middleware-go/ota.go

@@ -0,0 +1,459 @@
+package main
+
+import (
+	"context"
+	"encoding/json"
+	"fmt"
+	"io"
+	"log"
+	"math/rand"
+	"net/http"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"runtime"
+	"strconv"
+	"strings"
+	"sync"
+	"syscall"
+	"time"
+)
+
+// OTA 自更新：定期检查 GitHub Release，下载与当前平台匹配的新版二进制替换自身并重启。
+// 默认关闭，需显式开启（环境变量 OTA 或 setting.json 的 ota）。
+// 交接逻辑与后端 src/ota.go 保持一致：
+// 预检 → 原子替换 → 优雅停机 → 拉起新进程 → 健康检查确认 → 老进程退出；失败回滚 .old。
+
+const (
+	otaReleaseAPI    = "https://api.github.com/repos/nomdn/ipw-cn/releases/latest"
+	otaFirstDelay    = 5 * time.Minute // 启动后首次检查的延迟（错开启动高峰）
+	otaCheckInterval = 6 * time.Hour   // 常规检查间隔
+	otaMinSize       = 1 * 1024 * 1024 // 下载文件最小体积，防止拿到错误页/占位文件
+)
+
+var (
+	otaMu      sync.Mutex
+	otaLastRun time.Time
+)
+
+type otaRelease struct {
+	TagName string `json:"tag_name"`
+	Assets  []struct {
+		Name               string `json:"name"`
+		BrowserDownloadURL string `json:"browser_download_url"`
+		Size               int64  `json:"size"`
+	} `json:"assets"`
+}
+
+// otaEnabled 判断是否启用 OTA（"true" / "1" / "yes" / "on" 视为开启）
+func otaEnabled() bool {
+	switch strings.ToLower(strings.TrimSpace(OTA)) {
+	case "true", "1", "yes", "on":
+		return true
+	}
+	return false
+}
+
+// initOTA 在后台启动 OTA 检查循环，未启用时直接返回
+func initOTA(ghproxy string) {
+	if !otaEnabled() {
+		return
+	}
+	log.Printf("[ota] enabled, current_version=%s check_interval=%s", VERSION, otaCheckInterval)
+
+	go func() {
+		// 首次延迟，避免启动瞬间与节点建连/数据库等启动任务抢资源
+		time.Sleep(otaFirstDelay)
+		for {
+			checkOTAUpdate(ghproxy)
+			jitter := time.Duration(rand.Int63n(int64(time.Hour)))
+			time.Sleep(otaCheckInterval + jitter)
+		}
+	}()
+}
+
+// otaAssetNames 按优先级返回当前平台可能的发布资产名（与 build_and_release.yml 命名一致）
+func otaAssetNames() []string {
+	suffix := ""
+	if runtime.GOOS == "windows" {
+		suffix = ".exe"
+	}
+	arch := runtime.GOARCH
+	// GOARCH=arm 时无法在运行时区分 GOARM（armv7/armv6），依次尝试
+	if runtime.GOOS == "linux" && arch == "arm" {
+		return []string{
+			"middleware-go-linux-armv7",
+			"middleware-go-linux-armv6",
+			"middleware-go-linux-arm",
+		}
+	}
+	return []string{fmt.Sprintf("middleware-go-%s-%s%s", runtime.GOOS, arch, suffix)}
+}
+
+// compareVersion 比较版本号：latest > current 返回正数，相等返回 0，否则返回负数；
+// 非数字段按字典序比较。latest 为空（无法获取远端版本）时返回 0，不做更新。
+func compareVersion(latest, current string) int {
+	if strings.TrimSpace(latest) == "" {
+		return 0
+	}
+	trim := func(s string) string {
+		s = strings.TrimSpace(s)
+		s = strings.TrimPrefix(s, "v")
+		s = strings.TrimPrefix(s, "V")
+		if i := strings.IndexAny(s, "-+"); i >= 0 { // 忽略预发布后缀
+			s = s[:i]
+		}
+		return s
+	}
+	a := strings.Split(trim(latest), ".")
+	b := strings.Split(trim(current), ".")
+	for i := 0; i < len(a) || i < len(b); i++ {
+		var x, y int
+		var xe, ye error
+		if i < len(a) {
+			x, xe = strconv.Atoi(a[i])
+		}
+		if i < len(b) {
+			y, ye = strconv.Atoi(b[i])
+		}
+		switch {
+		case xe == nil && ye == nil:
+			if x != y {
+				return x - y
+			}
+		case xe == nil: // 只有当前版本非数字
+			return 1
+		case ye == nil:
+			return -1
+		default: // 两段都非数字，按字典序
+			if a[i] != b[i] {
+				if a[i] > b[i] {
+					return 1
+				}
+				return -1
+			}
+		}
+	}
+	return 0
+}
+
+// majorSame 判断 latest 与 current 的 major 段是否相同。
+// 任一段无法解析（如本地构建 VERSION 为空）时返回 true（放行，不拦截更新）。
+func majorSame(latest, current string) bool {
+	parseMajor := func(s string) (int, bool) {
+		s = strings.TrimSpace(s)
+		s = strings.TrimPrefix(s, "v")
+		s = strings.TrimPrefix(s, "V")
+		if i := strings.IndexAny(s, "-+."); i >= 0 {
+			s = s[:i]
+		}
+		n, err := strconv.Atoi(s)
+		if err != nil {
+			return 0, false
+		}
+		return n, true
+	}
+	lm, lok := parseMajor(latest)
+	cm, cok := parseMajor(current)
+	if !lok || !cok {
+		return true
+	}
+	return lm == cm
+}
+
+// fetchLatestRelease 查询 GitHub 最新 Release 信息
+func fetchLatestRelease() (*otaRelease, error) {
+	client := &http.Client{Timeout: 30 * time.Second}
+	req, err := http.NewRequest(http.MethodGet, otaReleaseAPI, nil)
+	if err != nil {
+		return nil, err
+	}
+	req.Header.Set("Accept", "application/vnd.github+json")
+	req.Header.Set("User-Agent", "middleware-go-ota")
+	resp, err := client.Do(req)
+	if err != nil {
+		return nil, err
+	}
+	defer resp.Body.Close()
+	if resp.StatusCode != http.StatusOK {
+		return nil, fmt.Errorf("HTTP %d", resp.StatusCode)
+	}
+	var rel otaRelease
+	if err := json.NewDecoder(resp.Body).Decode(&rel); err != nil {
+		return nil, err
+	}
+	if rel.TagName == "" {
+		return nil, fmt.Errorf("empty tag_name")
+	}
+	return &rel, nil
+}
+
+// findAssetURL 在 Release 资产中查找当前平台的下载链接，同时返回资产大小用于完整性校验
+func findAssetURL(rel *otaRelease) (string, string, int64) {
+	for _, want := range otaAssetNames() {
+		for _, a := range rel.Assets {
+			if a.Name == want {
+				return a.BrowserDownloadURL, a.Name, a.Size
+			}
+		}
+	}
+	return "", "", 0
+}
+
+// checkOTAUpdate 执行一次检查：有新版本则下载替换并重启
+func checkOTAUpdate(ghproxy string) {
+	otaMu.Lock()
+	defer otaMu.Unlock()
+	otaLastRun = time.Now()
+
+	rel, err := fetchLatestRelease()
+	if err != nil {
+		log.Printf("[ota] WARN check failed: %v", err)
+		return
+	}
+
+	if compareVersion(rel.TagName, VERSION) <= 0 {
+		return
+	}
+
+	// major 版本变化（如 3.x → 4.x）通常含破坏性变更，不自动更新，需人工升级
+	if !majorSame(rel.TagName, VERSION) {
+		log.Printf("[ota] skipped: major version upgrade requires manual action (latest=%s current=%s)", rel.TagName, VERSION)
+		return
+	}
+
+	assetURL, assetName, assetSize := findAssetURL(rel)
+	if assetURL == "" {
+		log.Printf("[ota] WARN no matching asset for this platform (goos=%s goarch=%s)", runtime.GOOS, runtime.GOARCH)
+		return
+	}
+
+	log.Printf("[ota] new version found: tag=%s current=%s asset=%s", rel.TagName, VERSION, assetName)
+
+	exePath, err := os.Executable()
+	if err != nil {
+		log.Printf("[ota] ERROR cannot locate executable: %v", err)
+		return
+	}
+	exePath, err = filepath.EvalSymlinks(exePath)
+	if err != nil {
+		log.Printf("[ota] ERROR cannot resolve executable path: %v", err)
+		return
+	}
+
+	// 下载到同目录（保证与目标同分区，rename 原子替换），
+	// 临时文件使用远端资产名 + .tmp 后缀，避免与运行中的 exe 冲突
+	tmpPath := filepath.Join(filepath.Dir(exePath), assetName+".tmp")
+	if err := downloadOTA(ghproxy+assetURL, tmpPath, assetSize); err != nil {
+		log.Printf("[ota] ERROR download failed: %v", err)
+		os.Remove(tmpPath)
+		return
+	}
+
+	// 预检：停机前先试运行新二进制（-v 打印版本即退出），确认文件可执行、架构匹配。
+	// 损坏/被杀毒隔离的文件若直到交接时才发现，子进程会秒退导致服务中断
+	if err := preflightBinary(tmpPath); err != nil {
+		log.Printf("[ota] ERROR preflight failed, keep current version: %v", err)
+		os.Remove(tmpPath)
+		return
+	}
+
+	if err := replaceBinary(tmpPath, exePath); err != nil {
+		log.Printf("[ota] ERROR replace failed: %v", err)
+		return
+	}
+
+	log.Printf("[ota] binary replaced, restarting (tag=%s)", rel.TagName)
+	restartSelf(exePath)
+}
+
+// preflightBinary 试运行新二进制（-v 自检：打印版本后立即退出，不读配置不占端口），
+// 确认文件可执行、架构匹配。10s 超时防损坏文件卡死。
+func preflightBinary(path string) error {
+	ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
+	defer cancel()
+	// Stdout/Stderr 为 nil 时输出直接丢弃
+	return exec.CommandContext(ctx, path, "-v").Run()
+}
+
+// downloadOTA 下载二进制到临时文件，并做体积校验（Release 声明的资产大小精确比对 + 最小体积兜底）。
+// 注意：GitHub Release 未提供签名/哈希清单，无法做内容级认证，体积校验只能防截断与错装文件。
+func downloadOTA(url, dst string, expectSize int64) error {
+	client := &http.Client{Timeout: 10 * time.Minute}
+	resp, err := client.Get(url)
+	if err != nil {
+		return err
+	}
+	defer resp.Body.Close()
+	if resp.StatusCode != http.StatusOK {
+		return fmt.Errorf("HTTP %d", resp.StatusCode)
+	}
+	f, err := os.Create(dst)
+	if err != nil {
+		return err
+	}
+	_, copyErr := io.Copy(f, resp.Body)
+	closeErr := f.Close()
+	if copyErr != nil || closeErr != nil {
+		os.Remove(dst) // 残缺文件不留
+		if copyErr != nil {
+			return copyErr
+		}
+		return closeErr
+	}
+	fi, err := os.Stat(dst)
+	if err != nil {
+		return err
+	}
+	if fi.Size() < otaMinSize {
+		os.Remove(dst)
+		return fmt.Errorf("downloaded file too small: %d bytes", fi.Size())
+	}
+	if expectSize > 0 && fi.Size() != expectSize {
+		os.Remove(dst)
+		return fmt.Errorf("downloaded size mismatch: got %d, want %d", fi.Size(), expectSize)
+	}
+	return nil
+}
+
+// replaceBinary 用新二进制替换当前可执行文件：
+// 1) 当前二进制改名为 .old（Windows 下运行中的 exe 不能删除，但可以重命名）
+// 2) 新文件 rename 到原位置；失败则回滚
+func replaceBinary(tmpPath, exePath string) error {
+	oldPath := exePath + ".old"
+	_ = os.Remove(oldPath)
+
+	if err := os.Rename(exePath, oldPath); err != nil {
+		return fmt.Errorf("backup current binary: %w", err)
+	}
+	if err := os.Rename(tmpPath, exePath); err != nil {
+		_ = os.Rename(oldPath, exePath) // 回滚
+		return fmt.Errorf("install new binary: %w", err)
+	}
+	if runtime.GOOS != "windows" {
+		if err := os.Chmod(exePath, 0o755); err != nil {
+			log.Printf("[ota] WARN chmod failed: %v", err)
+		}
+	}
+	return nil
+}
+
+// restartSelf 用新二进制重启进程：
+//   - Unix：syscall.Exec 原地替换进程镜像（PID 不变，systemd/Docker 无感；Go 的 socket 带
+//     CLOEXEC，exec 瞬间旧监听关闭、新进程正常重绑）
+//   - Windows：运行中的 exe 只能重命名不能替换，采用优雅交接：
+//     1) 优雅停机：停止接收新请求并等待在途请求完成，端口释放
+//     2) 拉起新进程：端口已空闲，子进程可正常绑定
+//     3) 轮询子进程健康检查通过后老进程才退出；失败回滚 .old 恢复服务
+func restartSelf(exePath string) {
+	if runtime.GOOS == "windows" {
+		gracefulShutdown()
+
+		cmd := exec.Command(exePath, os.Args[1:]...)
+		cmd.Stdout = os.Stdout
+		cmd.Stderr = os.Stderr
+		cmd.Env = os.Environ()
+		if err := cmd.Start(); err != nil {
+			log.Printf("[ota] ERROR restart failed, waiting for supervisor: %v", err)
+			os.Exit(1)
+		}
+
+		if waitChildReady(cmd, 10*time.Minute) {
+			log.Printf("[ota] new process ready, old process exiting (new_pid=%d)", cmd.Process.Pid)
+			os.Exit(0)
+		}
+		log.Printf("[ota] ERROR new process not ready (exited or timed out), rolling back (new_pid=%d)", cmd.Process.Pid)
+
+		// 回滚：新版本起不来，用 .old 备份恢复服务，而不是陪它一起下线
+		if rollbackToOld(exePath) {
+			log.Printf("[ota] WARN rolled back to previous version, old process exiting")
+			os.Exit(0)
+		}
+		os.Exit(1)
+	}
+
+	if err := syscall.Exec(exePath, os.Args, os.Environ()); err != nil {
+		log.Printf("[ota] ERROR exec failed, wait for supervisor to restart: %v", err)
+		os.Exit(1)
+	}
+}
+
+// gracefulShutdown 优雅停止 HTTP 服务：停止接收新请求，等待在途请求完成（上限 30s）。
+// 供 Windows OTA 在拉起新进程前调用，确保监听端口先释放、子进程能正常绑定。
+func gracefulShutdown() {
+	if fiberApp == nil {
+		return
+	}
+	otaShutdownStarted.Store(true)
+	log.Printf("[ota] graceful shutdown started, waiting for in-flight requests")
+	if err := fiberApp.ShutdownWithTimeout(30 * time.Second); err != nil {
+		log.Printf("[ota] WARN graceful shutdown: %v", err)
+	}
+}
+
+// waitChildReady 轮询新进程的健康检查接口（GET /），确认其完成端口绑定并对外服务。
+// 返回 true = 就绪；false = 子进程启动期间退出（立即判定失败）或超时未就绪。
+// 判定失败的依据是"子进程退出"（进程死了立即返回），而不是固定超时——
+// 10 分钟兜底只为覆盖慢启动场景。
+func waitChildReady(cmd *exec.Cmd, timeout time.Duration) bool {
+	client := &http.Client{Timeout: 2 * time.Second}
+	url := "http://127.0.0.1:" + PORT + "/"
+	deadline := time.Now().Add(timeout)
+
+	// 监听子进程退出：起不来直接失败，不用干等超时
+	exited := make(chan struct{})
+	go func() {
+		_ = cmd.Wait()
+		close(exited)
+	}()
+
+	for {
+		if resp, err := client.Get(url); err == nil {
+			resp.Body.Close()
+			return true
+		}
+		select {
+		case <-exited:
+			return false
+		case <-time.After(300 * time.Millisecond):
+		}
+		if time.Now().After(deadline) {
+			return false
+		}
+	}
+}
+
+// rollbackToOld 用 .old 备份恢复服务：新版本起不来时，把旧二进制换回原位并重新拉起。
+// 返回 true 表示旧版本已就绪。恢复失败时尽力把新二进制挪回原位后返回 false。
+func rollbackToOld(exePath string) bool {
+	oldPath := exePath + ".old"
+	if _, err := os.Stat(oldPath); err != nil {
+		log.Printf("[ota] ERROR rollback skipped: no .old backup: %v", err)
+		return false
+	}
+	failed := exePath + ".failed"
+	_ = os.Remove(failed)
+	if err := os.Rename(exePath, failed); err != nil {
+		log.Printf("[ota] ERROR rollback: cannot move failed binary: %v", err)
+		return false
+	}
+	if err := os.Rename(oldPath, exePath); err != nil {
+		log.Printf("[ota] ERROR rollback: cannot restore old binary: %v", err)
+		_ = os.Rename(failed, exePath) // 尽力恢复现场
+		return false
+	}
+	cmd := exec.Command(exePath, os.Args[1:]...)
+	cmd.Stdout = os.Stdout
+	cmd.Stderr = os.Stderr
+	cmd.Env = os.Environ()
+	if err := cmd.Start(); err != nil {
+		log.Printf("[ota] ERROR rollback: cannot start old binary: %v", err)
+		return false
+	}
+	if waitChildReady(cmd, 10*time.Minute) {
+		log.Printf("[ota] WARN rollback serving traffic on previous version (pid=%d)", cmd.Process.Pid)
+		return true
+	}
+	log.Printf("[ota] ERROR rollback: old binary also failed to become ready")
+	return false
+}

middleware-go/setting.json.example

@@ -4,23 +4,12 @@
     "rate-limit": 120,
     "ws-port": 8092,
     "remote-config-url": "",
-    "remote-ingore-config": [],
+    "remote-ignore-config": [],
     "cors": "",
-    "apiBaseUrls": [
-        {
-            "label": "中国 江苏 移动",
-            "id": "cn-jiangsu",
-            "url": "https://cn-jiangsu.api-ipw.wsmdn.top/"
-        }
-    ],
-    "IPLocationAPIs": [
-        {
-            "label": "中国 江苏 移动",
-            "id": "cn-jiangsu",
-            "url": "https://cn-jiangsu.api-ipw.wsmdn.top/"
-        }
-    ],
-    "TCPing": {
+    "trusted-proxies": "",
+    "gh-proxy": "",
+    "ota": "false",
+    "api-base-url": {
         "DualStack": [
             {
                 "label": "中国 江苏 移动",
@@ -31,23 +20,13 @@
         "IPv4": [],
         "IPv6": []
     },
-    "SpeedTest": {
-        "DualStack": [
-            {
-                "label": "中国 江苏 移动",
-                "id": "cn-jiangsu",
-                "url": "https://cn-jiangsu.api-ipw.wsmdn.top/"
-            }
-        ],
-        "IPv4": [],
-        "IPv6": []
-    },
-    "NSLookup": [
+    "ip-location-api": [
         {
             "label": "中国 江苏 移动",
             "id": "cn-jiangsu",
             "url": "https://cn-jiangsu.api-ipw.wsmdn.top/"
         }
     ],
-    "apiKeys": {}
-}
+    "api-keys": {},
+    "ws-keys": {}
+}

middleware-go/ws.go

@@ -7,6 +7,7 @@ import (
 	"log"
 	"net/http"
 	"sync"
+	"sync/atomic"
 	"time"
 
 	"github.com/coder/websocket"
@@ -54,7 +55,9 @@ type wsCommand struct {
 type wsPeer struct {
 	conn *websocket.Conn
 	id   string
-	last time.Time
+	// lastAtomic 最后收到消息的时间（unix nano）。读循环写、maintenanceLoop 读，
+	// 跨 goroutine 且不在 s.mu 保护内，必须原子访问
+	lastAtomic atomic.Int64
 }
 
 type wsServer struct {
@@ -91,6 +94,7 @@ func (s *wsServer) Handler(w http.ResponseWriter, r *http.Request) {
 
 	ctx := r.Context()
 	peer := &wsPeer{conn: c}
+	peer.lastAtomic.Store(time.Now().UnixNano())
 	registered := false
 
 	// 读循环
@@ -110,14 +114,14 @@ func (s *wsServer) Handler(w http.ResponseWriter, r *http.Request) {
 			log.Printf("[ws] invalid message from %s: %v", peer.id, err)
 			continue
 		}
-		peer.last = time.Now()
+		peer.lastAtomic.Store(time.Now().UnixNano())
 
 		// ===== 数据阶段 =====
 		switch msg.Type {
 		case "register":
 			var reg struct {
 				NodeID string `json:"nodeId"`
-				Key    string `json:"key"` // 注册凭证：与 setting.json apiKeys 配置比对
+				Key    string `json:"key"` // 注册凭证：与 setting.json wsKeys 配置比对
 			}
 			_ = json.Unmarshal(msg.Data, &reg)
 			if reg.NodeID == "" {
@@ -128,9 +132,9 @@ func (s *wsServer) Handler(w http.ResponseWriter, r *http.Request) {
 				s.sendJSON(c, wsMessage{Type: "register_error", Data: mustRaw(wsCommand{Command: "already registered"})})
 				continue
 			}
-			// 注册 key 校验：节点配置了 apiKeys[节点id] 就必须传对 key，否则 401 并断开；
+			// 注册 key 校验：节点配置了 wsKeys[节点id] 就必须传对 key，否则 401 并断开；
 			// 未配置 key 的节点（开放）无需传 key
-			if expected := lookupAPIKey(reg.NodeID); expected != "" && reg.Key != expected {
+			if expected := lookupWSKey(reg.NodeID); expected != "" && reg.Key != expected {
 				log.Printf("[ws] AUTH FAILED for node %s: invalid key", reg.NodeID)
 				s.sendJSON(c, wsMessage{Type: "register_error", Data: mustRaw(struct {
 					Code    int    `json:"code"`
@@ -194,10 +198,11 @@ func (s *wsServer) Handler(w http.ResponseWriter, r *http.Request) {
 	}
 }
 
-func (s *wsServer) sendJSON(c *websocket.Conn, msg wsMessage) {
+// sendJSON 发送 JSON 消息并返回写错误（写失败意味着对端连接已不可用，调用方应尽快失败）
+func (s *wsServer) sendJSON(c *websocket.Conn, msg wsMessage) error {
 	ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
 	defer cancel()
-	_ = c.Write(ctx, websocket.MessageText, mustRaw(msg))
+	return c.Write(ctx, websocket.MessageText, mustRaw(msg))
 }
 
 // RequestProbe 通过 WS 通道向指定节点发送拨测请求并等待结果（超时返回错误）。
@@ -221,7 +226,13 @@ func (s *wsServer) RequestProbe(nodeID, apiType, raw string, query map[string]st
 	}()
 
 	payload := wsProbeRequest{RequestID: reqID, APIType: apiType, Raw: raw, Query: query}
-	s.sendJSON(peer.conn, wsMessage{Type: "probe", NodeID: nodeID, TS: time.Now().Unix(), Data: mustRaw(payload)})
+	if err := s.sendJSON(peer.conn, wsMessage{Type: "probe", NodeID: nodeID, TS: time.Now().Unix(), Data: mustRaw(payload)}); err != nil {
+		// 连接已死（写失败立刻可知），直接返回错误，不再让请求干等满超时
+		s.statMu.Lock()
+		s.errReqs++
+		s.statMu.Unlock()
+		return 0, nil, fmt.Errorf("ws probe send failed for node %s: %w", nodeID, err)
+	}
 
 	s.statMu.Lock()
 	s.totalReqs++
@@ -292,6 +303,21 @@ func (s *wsServer) maintenanceLoop() {
 		s.statMu.Unlock()
 
 		for _, p := range peers {
+			// 空闲剔除：超过 75s（约 3 个心跳周期）没有任何消息的节点视为僵死。
+			// 不剔除的话死连接会永久占位，路由到它的探测全部干等超时
+			s.mu.Lock()
+			idle := time.Since(time.Unix(0, p.lastAtomic.Load()))
+			s.mu.Unlock()
+			if idle > 75*time.Second {
+				log.Printf("[ws] node %s idle for %s, evicting", p.id, idle.Round(time.Second))
+				p.conn.Close(websocket.StatusPolicyViolation, "idle timeout")
+				s.mu.Lock()
+				if cur, ok := s.peers[p.id]; ok && cur == p {
+					delete(s.peers, p.id)
+				}
+				s.mu.Unlock()
+				continue
+			}
 			// 心跳
 			s.sendJSON(p.conn, wsMessage{Type: "ping", NodeID: p.id, TS: time.Now().Unix()})
 			// 状态/统计上报

serverless/edgeone/cloud-functions/go.mod

@@ -33,14 +33,14 @@ require (
 	github.com/modern-go/reflect2 v1.0.2 // indirect
 	github.com/pelletier/go-toml/v2 v2.2.4 // indirect
 	github.com/quic-go/qpack v0.6.0 // indirect
-	github.com/quic-go/quic-go v0.59.0 // indirect
+	github.com/quic-go/quic-go v0.59.1 // indirect
 	github.com/twitchyliquid64/golang-asm v0.15.1 // indirect
 	github.com/ugorji/go/codec v1.3.1 // indirect
 	go.mongodb.org/mongo-driver/v2 v2.5.0 // indirect
 	golang.org/x/arch v0.23.0 // indirect
 	golang.org/x/crypto v0.52.0 // indirect
 	golang.org/x/mod v0.35.0 // indirect
-	golang.org/x/net v0.54.0 // indirect
+	golang.org/x/net v0.55.0 // indirect
 	golang.org/x/sync v0.20.0 // indirect
 	golang.org/x/sys v0.45.0 // indirect
 	golang.org/x/text v0.37.0 // indirect

serverless/edgeone/cloud-functions/go.sum

@@ -61,8 +61,8 @@ github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZb
 github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4=
 github.com/quic-go/qpack v0.6.0 h1:g7W+BMYynC1LbYLSqRt8PBg5Tgwxn214ZZR34VIOjz8=
 github.com/quic-go/qpack v0.6.0/go.mod h1:lUpLKChi8njB4ty2bFLX2x4gzDqXwUpaO1DP9qMDZII=
-github.com/quic-go/quic-go v0.59.0 h1:OLJkp1Mlm/aS7dpKgTc6cnpynnD2Xg7C1pwL6vy/SAw=
-github.com/quic-go/quic-go v0.59.0/go.mod h1:upnsH4Ju1YkqpLXC305eW3yDZ4NfnNbmQRCMWS58IKU=
+github.com/quic-go/quic-go v0.59.1 h1:0Gmua0HW1Tv7ANR7hUYwRyD0MG5OJfgvYSZasGZzBic=
+github.com/quic-go/quic-go v0.59.1/go.mod h1:upnsH4Ju1YkqpLXC305eW3yDZ4NfnNbmQRCMWS58IKU=
 github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME=
 github.com/stretchr/objx v0.4.0/go.mod h1:YvHI0jy2hoMjB+UWwv71VJQ9isScKT/TqJzVSSt89Yw=
 github.com/stretchr/objx v0.5.0/go.mod h1:Yh+to48EsGEfYuaHDzXPcE3xhTkx73EhmCGUpEOglKo=
@@ -88,8 +88,8 @@ golang.org/x/crypto v0.52.0 h1:RMs7fP2rXdep0CftQlK8Uf+kibLm7qkCcradZWYz988=
 golang.org/x/crypto v0.52.0/go.mod h1:1QgfPxDqh0T2M/elOJtp9RvuR95kVjir0e6/BvEmGbc=
 golang.org/x/mod v0.35.0 h1:Ww1D637e6Pg+Zb2KrWfHQUnH2dQRLBQyAtpr/haaJeM=
 golang.org/x/mod v0.35.0/go.mod h1:+GwiRhIInF8wPm+4AoT6L0FA1QWAad3OMdTRx4tFYlU=
-golang.org/x/net v0.54.0 h1:2zJIZAxAHV/OHCDTCOHAYehQzLfSXuf/5SoL/Dv6w/w=
-golang.org/x/net v0.54.0/go.mod h1:Sj4oj8jK6XmHpBZU/zWHw3BV3abl4Kvi+Ut7cQcY+cQ=
+golang.org/x/net v0.55.0 h1:bcvxaJn3e1U6InsFWt1JUq1aSjnRxLzT2rtD2KfkDF8=
+golang.org/x/net v0.55.0/go.mod h1:L5U2KuzuOe1lY7Z+aWVIKK6qEeJXnXV9yzGA+WCHJww=
 golang.org/x/sync v0.20.0 h1:e0PTpb7pjO8GAtTs2dQ6jYa5BWYlMuX047Dco/pItO4=
 golang.org/x/sync v0.20.0/go.mod h1:9xrNwdLfx4jkKbNva9FpL6vEN7evnE43NNNJQ2LF3+0=
 golang.org/x/sys v0.6.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=

serverless/edgeone/cloud-functions/index.go

@@ -241,6 +241,9 @@ func initHttpClient() {
 	V4Client.SetTransport(setTransport("tcp4"))
 	V6Client.SetTimeout(10 * time.Second)
 	V4Client.SetTimeout(10 * time.Second)
+	// 响应体上限：探针会读取任意用户提供的 URL，无上限时 10s 窗口内可灌入数 GB 导致 OOM
+	V6Client.SetResponseBodyLimit(10 * 1024 * 1024)
+	V4Client.SetResponseBodyLimit(10 * 1024 * 1024)
 	V6Client.SetRedirectPolicy(resty.RedirectPolicyFunc(ssrf.SecureCheckRedirect))
 	V4Client.SetRedirectPolicy(resty.RedirectPolicyFunc(ssrf.SecureCheckRedirect))
 	V6Client.AddContentDecompresser("zstd", decompressZstd)
@@ -555,13 +558,15 @@ func cleanHostRecord(addr string) string {
 
 func normalizeURL(input string) string {
 	input = strings.TrimSpace(input)
-	input = strings.TrimPrefix(input, "/")
 	if strings.HasPrefix(input, "http://") || strings.HasPrefix(input, "https://") {
 		return input
 	}
+	// 协议相对路径必须先于剥前导斜杠判断，否则 "//example.com" 被剥成 "/example.com"，
+	// 该分支永远不会命中，最终拼出空 host 的 "https:///example.com"
 	if strings.HasPrefix(input, "//") {
 		return "https:" + input
 	}
+	input = strings.TrimPrefix(input, "/")
 	return "https://" + input
 }
 
@@ -581,8 +586,8 @@ func checkWebsiteHandler(c *gin.Context) {
 
 	testUrl = normalizeURL(testUrl)
 
-	parsedURL, _ := url.Parse(testUrl)
-	if ssrf.HasLocalOrPrivateIP(parsedURL.Hostname()) {
+	parsedURL, err := url.Parse(testUrl)
+	if err == nil && ssrf.HasLocalOrPrivateIP(parsedURL.Hostname()) {
 		c.JSON(200, &WebsiteCheckResult{
 			IPv4: fakePerfectWebsiteResult(testUrl),
 			IPv6: fakePerfectWebsiteResult(testUrl),
@@ -682,8 +687,8 @@ func sslCheckHandler(c *gin.Context) {
 
 	testUrl = normalizeURL(testUrl)
 
-	parsedURL, _ := url.Parse(testUrl)
-	if ssrf.HasLocalOrPrivateIP(parsedURL.Hostname()) {
+	parsedURL, err := url.Parse(testUrl)
+	if err == nil && ssrf.HasLocalOrPrivateIP(parsedURL.Hostname()) {
 		c.JSON(200, &SSLCheckResult{
 			IPv4: fakeInvalidSSLResult(parsedURL.Hostname()),
 			IPv6: fakeInvalidSSLResult(parsedURL.Hostname()),
@@ -1179,7 +1184,7 @@ func applyRemoteConfig() {
 		ssrf.SetEnabled(v != "false" && v != "0")
 	}
 	if CORS != "" {
-		ACCEPT_DOMAINS = strings.Split(CORS, ",")
+		ACCEPT_DOMAINS = splitAndTrim(CORS, ",")
 	}
 	slog.Info("Remote config applied", "url", url)
 }
@@ -1216,17 +1221,73 @@ func readConfig() {
 		PORTS = "8080"
 	}
 	if CORS != "" {
-		ACCEPT_DOMAINS = strings.Split(CORS, ",")
+		ACCEPT_DOMAINS = splitAndTrim(CORS, ",")
 	}
 	slog.Info("SSRF protection initialized", "blockPrivateIPs", ssrf.Enabled())
 }
 
+// splitAndTrim 按逗号切分并去掉每段首尾空白：CORS 配置 "a.com, b.com" 带空格时，
+// 直接 Split 会产生带前导空格的 origin，永远匹配不上请求头
+func splitAndTrim(s, sep string) []string {
+	parts := strings.Split(s, sep)
+	out := make([]string, 0, len(parts))
+	for _, p := range parts {
+		if p = strings.TrimSpace(p); p != "" {
+			out = append(out, p)
+		}
+	}
+	return out
+}
+
+// sweepExpiredCaches 按条目时间戳清扫各 sync.Map 缓存（TTL 均为 5 分钟，清扫窗口取 10 分钟），
+// 缓存条目只在同 key 重访时惰性淘汰，公网端点被唯一 key 洪打时内存会无限增长
+func sweepExpiredCaches() {
+	cutoff := time.Now().Add(-10 * time.Minute)
+	sweep := func(m *sync.Map) {
+		m.Range(func(k, v any) bool {
+			var ts time.Time
+			switch e := v.(type) {
+			case websiteCacheEntry:
+				ts = e.timestamp
+			case sslCacheEntry:
+				ts = e.timestamp
+			case pingCacheEntry:
+				ts = e.timestamp
+			case speedCacheEntry:
+				ts = e.timestamp
+			case whoisCacheEntry:
+				ts = e.timestamp
+			default:
+				return true
+			}
+			if ts.Before(cutoff) {
+				m.Delete(k)
+			}
+			return true
+		})
+	}
+	sweep(&websiteCache)
+	sweep(&sslCache)
+	sweep(&pingCache)
+	sweep(&speedCache)
+	sweep(&whoisCache)
+}
+
 func main() {
 	readConfig()
 	initHttpClient()
 	webtest.SetDNSServer(DNS_SERVER)
 	webtest.SetDNSSecServer(DNSSEC_DNS_SERVER)
 	slog.Info("Starting server", "port", PORTS, "single_stack", SINGLE_STACK)
+
+	// 缓存清扫：定期淘汰过期条目
+	go func() {
+		for {
+			time.Sleep(10 * time.Minute)
+			sweepExpiredCaches()
+		}
+	}()
+
 	r := gin.Default()
 	corsConfig := cors.DefaultConfig()
 	if len(ACCEPT_DOMAINS) > 0{

serverless/edgeone/cloud-functions/ssrf/ssrf.go

@@ -45,24 +45,49 @@ func SetEnabled(v bool) {
 	blockPrivateIPs = v
 }
 
+// Go 标准库 IsPrivate 只覆盖 RFC1918 与 fd00::/8，这里补齐其余不应出网的内部/特殊网段
+var extraPrivateNets = mustParseCIDRs(
+	"100.64.0.0/10", // CGNAT：运营商级 NAT、云内网、Tailscale 等
+	"198.18.0.0/15", // 网络基准测试保留段
+	"192.0.0.0/24",  // IETF 协议分配
+	"fc00::/7",      // IPv6 ULA（IsPrivate 只认 fd00::/8）
+	"64:ff9b::/96",  // NAT64：内嵌 IPv4 会被网关转换
+)
+
+func mustParseCIDRs(cidrs ...string) []*net.IPNet {
+	nets := make([]*net.IPNet, 0, len(cidrs))
+	for _, c := range cidrs {
+		_, ipNet, err := net.ParseCIDR(c)
+		if err != nil {
+			panic(fmt.Sprintf("invalid CIDR %q: %v", c, err))
+		}
+		nets = append(nets, ipNet)
+	}
+	return nets
+}
+
 // IsPrivateIP checks if the given IP address belongs to a private or internal range.
 // IsPrivateIP 检查给定的 IP 地址是否属于私有或内部地址段。
-// It covers RFC 1918 private addresses, loopback, link-local, and unspecified addresses.
-// 涵盖 RFC 1918 私有地址、回环地址、链路本地地址和未指定地址。
+// It covers RFC 1918 private addresses, loopback, link-local, and unspecified addresses,
+// plus CGNAT/ULA/NAT64/benchmark/multicast ranges that Go's IsPrivate does not cover.
+// 涵盖 RFC 1918 私有地址、回环地址、链路本地地址和未指定地址，
+// 以及 Go 标准库未覆盖的 CGNAT/ULA/NAT64/基准测试/组播段。
 // This is the core check used to block SSRF attacks targeting internal networks.
 // 这是用于阻止针对内部网络的 SSRF 攻击的核心检查。
 func IsPrivateIP(ip net.IP) bool {
-	if ip.IsPrivate() {
+	if ip == nil {
+		return false
+	}
+	if ip.IsPrivate() || ip.IsLoopback() || ip.IsLinkLocalUnicast() || ip.IsUnspecified() || ip.IsMulticast() {
 		return true
 	}
-	if ip.IsLoopback() {
+	if ip.Equal(net.IPv4bcast) {
 		return true
 	}
-	if ip.IsLinkLocalUnicast() {
-		return true
-	}
-	if ip.IsUnspecified() {
-		return true
+	for _, n := range extraPrivateNets {
+		if n.Contains(ip) {
+			return true
+		}
 	}
 	return false
 }
@@ -133,36 +158,35 @@ func ValidateOutboundTarget(ctx context.Context, targetURL string) (context.Cont
 // SecureCheckRedirect is a redirect policy that prevents SSRF via HTTP redirect chains.
 // SecureCheckRedirect 是一个重定向策略，防止通过 HTTP 重定向链进行 SSRF 攻击。
 //
-// When an HTTP client follows redirects (301, 302, 307, 308), each intermediate target
-// 当 HTTP 客户端跟随重定向（301、302、307、308）时，会校验每个中间目标
-// is resolved and checked against private/internal IP ranges.
-// 的解析结果，并检查是否指向私有/内部 IP 段。
-//
-// This blocks attackers from:
-// 这阻止攻击者通过以下方式绕过防护：
-//   - Using an initial public redirect that points to an internal service.
-//     使用指向内部服务的初始公开重定向。
-//   - Chaining multiple redirects to eventually reach a private IP.
-//     链式多个重定向最终到达私有 IP。
+// req 是即将跳转的目标（via 是已访问的链）。必须校验目标本身：
+// 只检查 via 会漏掉重定向链的最后一跳。每一跳的目标都会被解析并检查
+// 是否指向私有/内部 IP 段，同时限制重定向深度。
+// 这阻止攻击者通过链式重定向最终到达私有 IP。
 func SecureCheckRedirect(req *http.Request, via []*http.Request) error {
 	if !blockPrivateIPs {
 		return nil
 	}
-	for _, r := range via {
-		redirectURL := r.URL
-		host := redirectURL.Hostname()
-		if host == "" {
-			continue
-		}
-		ips, err := net.LookupIP(host)
-		if err != nil {
-			return err
-		}
-		for _, ip := range ips {
-			if IsPrivateIP(ip) {
-				slog.Warn("Blocked redirect to private IP", "host", host, "ip", ip)
-				return fmt.Errorf("redirect to private/internal address is not allowed")
-			}
+	if req == nil || req.URL == nil {
+		return fmt.Errorf("invalid redirect target")
+	}
+	if req.URL.Scheme != "http" && req.URL.Scheme != "https" {
+		return fmt.Errorf("invalid redirect scheme: %s", req.URL.Scheme)
+	}
+	host := req.URL.Hostname()
+	if host == "" {
+		return fmt.Errorf("redirect target has empty host")
+	}
+	if len(via) >= 10 {
+		return fmt.Errorf("stopped after 10 redirects")
+	}
+	ips, err := net.LookupIP(host)
+	if err != nil {
+		return err
+	}
+	for _, ip := range ips {
+		if IsPrivateIP(ip) {
+			slog.Warn("Blocked redirect to private IP", "host", host, "ip", ip)
+			return fmt.Errorf("redirect to private/internal address is not allowed")
 		}
 	}
 	return nil

serverless/edgeone/cloud-functions/webtest/tcping.go

@@ -5,6 +5,8 @@ import (
 	"math"
 	"net"
 	"time"
+
+	"edgeone-cloud-functions/ssrf"
 )
 
 type TCPingResult struct {
@@ -37,6 +39,13 @@ func TCPing(host string, port string, version string, timeout time.Duration) (*T
 	if err != nil {
 		return nil, err
 	}
+	// SSRF 防护：内网/云元数据段（127.0.0.1、10.x、169.254.169.254 等）直接拒绝，
+	// 否则 tcping 接口会被当作内网端口扫描器
+	if ssrf.Enabled() {
+		if pip := net.ParseIP(ip); pip != nil && ssrf.IsPrivateIP(pip) {
+			return nil, fmt.Errorf("request to private/internal address is not allowed")
+		}
+	}
 	addr := ""
 	switch version {
 	case "v4":

serverless/edgeone/cloud-functions/webtest/whois.go

@@ -1,6 +1,7 @@
 package webtest
 
 import (
+	"bytes"
 	"context"
 	"fmt"
 	"net"
@@ -343,19 +344,29 @@ func rawWhoisQueryCtx(ctx context.Context, domain, server, port string) (string,
 		}
 	}
 
-	// 3. 读取响应
+	// 3. 读取响应：循环读到 EOF/超时。单次 Read 只能拿到一个 TCP 段，会截断大多数 WHOIS 响应
 	buf := make([]byte, 65536)
-	n, readErr := conn.Read(buf)
-
-	// 有数据就读到了，哪怕 readErr != nil 也先返回数据
-	if n > 0 {
-		return string(buf[:n]), nil
-	}
-	select {
-	case <-ctx.Done():
-		return "", ctx.Err()
-	default:
-		return "", readErr
+	var out bytes.Buffer
+	for {
+		n, readErr := conn.Read(buf)
+		if n > 0 {
+			out.Write(buf[:n])
+		}
+		if readErr != nil {
+			// 有数据就返回（EOF/超时都视为读完），哪怕 readErr != nil
+			if out.Len() > 0 {
+				return out.String(), nil
+			}
+			select {
+			case <-ctx.Done():
+				return "", ctx.Err()
+			default:
+				return "", readErr
+			}
+		}
+		if out.Len() > 1<<20 { // 防御上限 1MB，避免异常响应无限读
+			return out.String(), nil
+		}
 	}
 }
 

serverless/lemon-getip/package.json

@@ -10,10 +10,10 @@
 		"cf-typegen": "wrangler types"
 	},
 	"devDependencies": {
-		"@cloudflare/vitest-pool-workers": "^0.18.5",
+		"@cloudflare/vitest-pool-workers": "^0.22.0",
 		"typescript": "^5.5.2",
 		"vitest": "~4.1.10",
-		"wrangler": "^4.111.0"
+		"wrangler": "^4.124.0"
 	},
 	"dependencies": {
 		"hono": "^4.12.34"

setting.json

@@ -1,15 +0,0 @@
-{
-    "port": 8080,
-    "gh-proxy": "",
-    "single-stack": "",
-    "dns-server": "",
-    "dnssec-server": "",
-    "block-private-ips": true,
-    "ipdb": true,
-    "cors": "",
-    "remote-config-url": "",
-    "remote-ingore-config": [],
-    "access_token": "",
-    "ws-url": "",
-    "node-id": ""
-}

src/Dockerfile

@@ -0,0 +1,43 @@
+# 多架构构建：buildx 会注入 TARGETOS/TARGETARCH，构建阶段固定在构建机原生平台
+# （--platform=$BUILDPLATFORM）交叉编译，目标架构无需 QEMU 模拟；未用 buildx 时
+# TARGETOS/TARGETARCH 为空，Go 默认取宿主机平台，普通 docker build 仍然可用
+FROM --platform=$BUILDPLATFORM golang:1.26-alpine AS build
+ARG TARGETOS
+ARG TARGETARCH
+ARG TARGETVARIANT
+ENV GO111MODULE=on \
+    CGO_ENABLED=0 \
+    GOOS=${TARGETOS} \
+    GOARCH=${TARGETARCH}
+WORKDIR /app
+COPY go.mod go.sum ./
+RUN go mod download
+COPY *.go ./
+COPY webtest/ ./webtest/
+COPY ipdb/ ./ipdb/
+COPY ssrf/ ./ssrf/
+# TARGETVARIANT 是 buildx 的 "v7"/"v6" 写法，Go 的 GOARM 只要数字；不映射时 GOARCH=arm 默认按 GOARM=6 编译
+RUN set -eux; \
+    case "$TARGETVARIANT" in \
+      v7) export GOARM=7 ;; \
+      v6) export GOARM=6 ;; \
+    esac; \
+    go build -o main .
+
+# 运行阶段
+FROM alpine:latest
+
+# 添加必要的证书
+RUN apk --no-cache add ca-certificates
+
+# 创建非root用户
+RUN adduser -D appuser
+USER appuser
+
+WORKDIR /home/appuser
+
+# 从构建阶段复制二进制文件
+COPY --from=build /app/main .
+
+EXPOSE 8080
+CMD ["./main"]

src/go.mod

@@ -1,11 +1,13 @@
 module lemon-ipw
 
-go 1.26.2
+go 1.26.6
 
 require (
+	github.com/AdguardTeam/golibs v0.35.16
 	github.com/coder/websocket v1.8.15
 	github.com/gin-contrib/cors v1.7.7
 	github.com/gin-gonic/gin v1.12.0
+	github.com/ip2location/ip2location-go/v9 v9.8.0
 	github.com/ipipdotnet/ipdb-go v1.3.3
 	github.com/klauspost/compress v1.19.1
 	github.com/likexian/whois v1.15.7
@@ -54,10 +56,11 @@ require (
 	go.yaml.in/yaml/v3 v3.0.4 // indirect
 	golang.org/x/arch v0.23.0 // indirect
 	golang.org/x/crypto v0.54.0 // indirect
-	golang.org/x/mod v0.37.0 // indirect
+	golang.org/x/mod v0.38.0 // indirect
 	golang.org/x/net v0.57.0 // indirect
 	golang.org/x/sys v0.47.0 // indirect
 	golang.org/x/text v0.40.0 // indirect
-	golang.org/x/tools v0.47.0 // indirect
-	google.golang.org/protobuf v1.36.10 // indirect
+	golang.org/x/tools v0.48.0 // indirect
+	google.golang.org/protobuf v1.36.11 // indirect
+	lukechampine.com/uint128 v1.2.0 // indirect
 )

src/go.sum

@@ -1,3 +1,5 @@
+github.com/AdguardTeam/golibs v0.35.16 h1:e9dyk7jfzpxMcyVZ8RktKV6JMeiQ9MpEhp/Ahm3j/R4=
+github.com/AdguardTeam/golibs v0.35.16/go.mod h1:lGsRwlo3R3ma5o8mgdDv3I+6DYTiCHfrhNyUamqhbK8=
 github.com/bytedance/gopkg v0.1.3 h1:TPBSwH8RsouGCBcMBktLt1AymVo2TVsBVCY4b6TnZ/M=
 github.com/bytedance/gopkg v0.1.3/go.mod h1:576VvJ+eJgyCzdjS+c4+77QF3p7ubbtiKARP3TxducM=
 github.com/bytedance/sonic v1.15.0 h1:/PXeWFaR5ElNcVE84U0dOHjiMHQOwNIx3K4ymzh/uSE=
@@ -9,8 +11,9 @@ github.com/cloudwego/base64x v0.1.6/go.mod h1:OFcloc187FXDaYHvrNIjxSe8ncn0OOM8gE
 github.com/coder/websocket v1.8.15 h1:6B2JPeOGlpff2Uz6vOEH1Vzpi0iUz20A+lPVhPHtNUA=
 github.com/coder/websocket v1.8.15/go.mod h1:NX3SzP+inril6yawo5CQXx8+fk145lPDC6pumgx0mVg=
 github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
-github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c=
 github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
+github.com/davecgh/go-spew v1.1.2-0.20180830191138-d8f796af33cc h1:U9qPSI2PIWSS1VwoXQT9A3Wy9MM3WgvqSxFWenqJduM=
+github.com/davecgh/go-spew v1.1.2-0.20180830191138-d8f796af33cc/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
 github.com/frankban/quicktest v1.14.6 h1:7Xjx+VpznH+oBnejlPUj8oUpdxnVs4f8XU8WnHkI4W8=
 github.com/frankban/quicktest v1.14.6/go.mod h1:4ptaffx2x8+WTWXmUCuVU6aPUX1/Mz7zb5vbUoiM6w0=
 github.com/fsnotify/fsnotify v1.9.0 h1:2Ml+OJNzbYCTzsxtv8vKSFD9PbJjmhYF14k/jKC7S9k=
@@ -40,6 +43,8 @@ github.com/goccy/go-yaml v1.19.2/go.mod h1:XBurs7gK8ATbW4ZPGKgcbrY1Br56PdM69F7Lk
 github.com/google/go-cmp v0.7.0 h1:wk8382ETsv4JYUZwIsn6YpYiWiBsYLSJiTsyBybVuN8=
 github.com/google/go-cmp v0.7.0/go.mod h1:pXiqmnSA92OHEEa9HXL2W4E7lf9JzCmGVUdgjX3N/iU=
 github.com/google/gofuzz v1.0.0/go.mod h1:dBl0BpW6vV/+mYPU4Po3pmUjxk6FQPldtuIdl/M65Eg=
+github.com/ip2location/ip2location-go/v9 v9.8.0 h1:drPzGjj1EBl45I33ErMHFtIfsQ3mR85dAQbqMDbi9mc=
+github.com/ip2location/ip2location-go/v9 v9.8.0/go.mod h1:MPLnsKxwQlvd2lBNcQCsLoyzJLDBFizuO67wXXdzoyI=
 github.com/ipipdotnet/ipdb-go v1.3.3 h1:GLSAW9ypLUd6EF9QNK2Uhxew9Jzs4XMJ9gOZEFnJm7U=
 github.com/ipipdotnet/ipdb-go v1.3.3/go.mod h1:yZ+8puwe3R37a/3qRftXo40nZVQbxYDLqls9o5foexs=
 github.com/json-iterator/go v1.1.12 h1:PV8peI4a0ysnczrg+LtxykD8LfKY9ML6u2jnxaEnrnM=
@@ -75,14 +80,15 @@ github.com/oschwald/maxminddb-golang/v2 v2.3.0 h1:PnXjMGjkSQlwOBSyZ7hk6Fd75t7erk
 github.com/oschwald/maxminddb-golang/v2 v2.3.0/go.mod h1:NSQvgFwPxODpBTJI5+5Ns1AAucnx7ggW9PSRRifAT1s=
 github.com/pelletier/go-toml/v2 v2.2.4 h1:mye9XuhQ6gvn5h28+VilKrrPoQVanw5PMw/TB0t5Ec4=
 github.com/pelletier/go-toml/v2 v2.2.4/go.mod h1:2gIqNv+qfxSVS7cM2xJQKtLSTLUE9V8t9Stt+h56mCY=
-github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM=
 github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4=
+github.com/pmezard/go-difflib v1.0.1-0.20181226105442-5d4384ee4fb2 h1:Jamvg5psRIccs7FGNTlIRMkT8wgtp5eCXdBlqhYGL6U=
+github.com/pmezard/go-difflib v1.0.1-0.20181226105442-5d4384ee4fb2/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4=
 github.com/quic-go/qpack v0.6.0 h1:g7W+BMYynC1LbYLSqRt8PBg5Tgwxn214ZZR34VIOjz8=
 github.com/quic-go/qpack v0.6.0/go.mod h1:lUpLKChi8njB4ty2bFLX2x4gzDqXwUpaO1DP9qMDZII=
 github.com/quic-go/quic-go v0.59.1 h1:0Gmua0HW1Tv7ANR7hUYwRyD0MG5OJfgvYSZasGZzBic=
 github.com/quic-go/quic-go v0.59.1/go.mod h1:upnsH4Ju1YkqpLXC305eW3yDZ4NfnNbmQRCMWS58IKU=
-github.com/rogpeppe/go-internal v1.10.0 h1:TMyTOH3F/DB16zRVcYyreMH6GnZZrwQVAoYjRBZyWFQ=
-github.com/rogpeppe/go-internal v1.10.0/go.mod h1:UQnix2H7Ngw/k4C5ijL5+65zddjncjaFoBhdsK/akog=
+github.com/rogpeppe/go-internal v1.15.0 h1:D0RCU5rMAp+SpgkiNdrjfJ+LX4J1M32V2NeCY7EJ6hc=
+github.com/rogpeppe/go-internal v1.15.0/go.mod h1:DrUVZyrJU+txYW5/1kwtXQSMFio52ZOxX7yM1VHvnxs=
 github.com/sagikazarmark/locafero v0.11.0 h1:1iurJgmM9G3PA/I+wWYIOw/5SyBtxapeHDcg+AAIFXc=
 github.com/sagikazarmark/locafero v0.11.0/go.mod h1:nVIGvgyzw595SUSUE6tvCp3YYTeHs15MvlmU87WwIik=
 github.com/sourcegraph/conc v0.3.1-0.20240121214520-5f936abd7ae8 h1:+jumHNA0Wrelhe64i8F6HNlS8pkoyMv5sreGx2Ry5Rw=
@@ -122,8 +128,8 @@ golang.org/x/arch v0.23.0 h1:lKF64A2jF6Zd8L0knGltUnegD62JMFBiCPBmQpToHhg=
 golang.org/x/arch v0.23.0/go.mod h1:dNHoOeKiyja7GTvF9NJS1l3Z2yntpQNzgrjh1cU103A=
 golang.org/x/crypto v0.54.0 h1:YLIA59K4fiNzHzjnZt2tUJQjQtUWfWbeHBqKtk3eScw=
 golang.org/x/crypto v0.54.0/go.mod h1:KWL8ny2AZdGR2cWmzeHrp2azQPGogOv+HeQaVEXC2dk=
-golang.org/x/mod v0.37.0 h1:vF1DjpVEshcIqoEaauuHebaLk1O1forxjxBaVn884JQ=
-golang.org/x/mod v0.37.0/go.mod h1:m8S8VeM9r4dzDwjrKO0a1sZP3YjeMamRRlD+fmR2Q/0=
+golang.org/x/mod v0.38.0 h1:MECBjubtXD7yj4HrhIUcywNaGeNVUdfVnxmPajOk4yk=
+golang.org/x/mod v0.38.0/go.mod h1:V6Xz0pq8TQ3dGqVQ1FVHuelZpAL0uNhSkk9ogYP3c40=
 golang.org/x/net v0.57.0 h1:K5+3DljvIuDG9/Jv9rvyMywYNFCQ9RSUY6OOTTkT+tE=
 golang.org/x/net v0.57.0/go.mod h1:KpXc8iv+r3XplLAG/f7Jsf9RPszJzdR0f58q9vGOuEU=
 golang.org/x/sync v0.22.0 h1:SZjpbeLmrCk4xhRSZFNZW5gFUeCeFgjekvI/+gfScek=
@@ -133,15 +139,17 @@ golang.org/x/sys v0.47.0 h1:o7XGOvZQCADBQQ4Y7VNq2dRWQR7JmOUW8Kxx4ZsNgWs=
 golang.org/x/sys v0.47.0/go.mod h1:4GL1E5IUh+htKOUEOaiffhrAeqysfVGipDYzABqnCmw=
 golang.org/x/text v0.40.0 h1:Ub2Z6/xjgF1WrYQz2nuITOEegKFtiIy+rieRJ5lHZKs=
 golang.org/x/text v0.40.0/go.mod h1:hpnzDAfGV753zIKo+wk3u1bVKCGPbrnF7+7LBF/UHVY=
-golang.org/x/tools v0.47.0 h1:7Kn5x/d1svx/PzryTsqeoZN4TZwqeH5pGWjefhLi/1Q=
-golang.org/x/tools v0.47.0/go.mod h1:dFHnyTvFWY212G+h7ZY4Vsp/K3U4/7W9TyVaAul8uCA=
-google.golang.org/protobuf v1.36.10 h1:AYd7cD/uASjIL6Q9LiTjz8JLcrh/88q5UObnmY3aOOE=
-google.golang.org/protobuf v1.36.10/go.mod h1:HTf+CrKn2C3g5S8VImy6tdcUvCska2kB7j23XfzDpco=
+golang.org/x/tools v0.48.0 h1:3+hClM1aLL5mjMKm5ovokw9epgRXPuu2tILgismM6RE=
+golang.org/x/tools v0.48.0/go.mod h1:08xX0orndb/F7jJxGDicx061tyd5pcMto75YMAXr6lk=
+google.golang.org/protobuf v1.36.11 h1:fV6ZwhNocDyBLK0dj+fg8ektcVegBBuEolpbTQyBNVE=
+google.golang.org/protobuf v1.36.11/go.mod h1:HTf+CrKn2C3g5S8VImy6tdcUvCska2kB7j23XfzDpco=
 gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
 gopkg.in/check.v1 v1.0.0-20201130134442-10cb98267c6c h1:Hei/4ADfdWqJk1ZMxUNpqntNwaWcugrBjAiHlqqRiVk=
 gopkg.in/check.v1 v1.0.0-20201130134442-10cb98267c6c/go.mod h1:JHkPIbrfpd72SG/EVd6muEfDQjcINNoR0C8j2r3qZ4Q=
 gopkg.in/yaml.v3 v3.0.0-20200313102051-9f266ea9e77c/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=
 gopkg.in/yaml.v3 v3.0.1 h1:fxVm/GzAzEWqLHuvctI91KS9hhNmmWOoWu0XTYJS7CA=
 gopkg.in/yaml.v3 v3.0.1/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=
+lukechampine.com/uint128 v1.2.0 h1:mBi/5l91vocEN8otkC5bDLhi2KdCticRiwbdB0O+rjI=
+lukechampine.com/uint128 v1.2.0/go.mod h1:c4eWIwlEGaxC/+H1VguhU4PHXNWDCDMUlWdIWl2j1gk=
 resty.dev/v3 v3.0.0-beta.6 h1:ghRdNpoE8/wBCv+kTKIOauW1aCrSIeTq7GxtfYgtevU=
 resty.dev/v3 v3.0.0-beta.6/go.mod h1:NTOerrC/4T7/FE6tXIZGIysXXBdgNqwMZuKtxpea9NM=

src/ipdb/ipdb.go

@@ -1,6 +1,7 @@
 package ipdb
 
 import (
+	"archive/zip"
 	"compress/gzip"
 	"fmt"
 	"io"
@@ -31,6 +32,8 @@ func PullDatabase(ghproxy string) error {
 		{ghproxy + "https://github.com/ljxi/GeoCN/releases/latest/download/GeoCN.mmdb", "GeoCN.mmdb"},
 		{ghproxy + "https://raw.githubusercontent.com/wp-statistics/DbIP-City-lite/master/dbip-city-lite.mmdb.gz", "dbip-city-lite.mmdb.gz"},
 		{ghproxy + "https://github.com/jcjc-dev/mmdb-latest/releases/download/dbip-latest/dbip-asn-lite.mmdb", "dbip-asn-lite.mmdb"},
+		{ghproxy + "https://github.com/nomdn/ip2location/releases/latest/download/IP2LOCATION-LITE-DB11.IPV6.BIN.ZIP", "IP2LOCATION-LITE-DB11.IPV6.BIN.ZIP"},
+		{ghproxy + "https://github.com/nomdn/ip2location/releases/latest/download/IP2LOCATION-LITE-ASN.IPV6.BIN.zip", "IP2LOCATION-LITE-ASN.IPV6.BIN.zip"},
 	}
 
 	tmpDir := "./tmp"
@@ -62,7 +65,12 @@ func PullDatabase(ghproxy string) error {
 	}
 
 	slog.Info("Copying downloaded files to working directory...")
-	for _, t := range tasks {
+	for i, t := range tasks {
+		if errs[i] != nil {
+			// 下载失败（含传输中断留下的残缺文件）不覆盖现有数据库
+			slog.Warn("Skipping failed download, keep existing file", "file", t.name)
+			continue
+		}
 		src := filepath.Join(tmpDir, t.name)
 		if _, err := os.Stat(src); os.IsNotExist(err) {
 			slog.Warn("Skipping missing file", "file", t.name)
@@ -73,14 +81,25 @@ func PullDatabase(ghproxy string) error {
 			slog.Error("Failed to copy file", "file", t.name, "error", err)
 			continue
 		}
-		if strings.HasSuffix(t.name, ".gz") {
-			outName := strings.TrimSuffix(t.name, ".gz")
+		lower := strings.ToLower(t.name)
+		// 后缀判断用小写比较：IP2LOCATION 的资产名是大写 .ZIP，原来 HasSuffix(".zip") 永远匹配不上，
+		// 导致该数据库从不解压就被删除
+		if strings.HasSuffix(lower, ".gz") {
+			outName := t.name[:len(t.name)-3]
 			slog.Info("Decompressing...", "file", t.name, "output", outName)
 			if err := gunzipFile(dst, "./"+outName); err != nil {
 				slog.Error("Failed to decompress", "file", t.name, "error", err)
 			}
 			os.Remove(dst)
 		}
+		if strings.HasSuffix(lower, ".zip") {
+			outName := t.name[:len(t.name)-4]
+			slog.Info("Unzipping...", "file", t.name, "output", outName)
+			if err := unzipFile(dst, "./"+outName); err != nil {
+				slog.Error("Failed to unzip", "file", t.name, "error", err)
+			}
+			os.Remove(dst)
+		}
 	}
 
 	os.RemoveAll(tmpDir)
@@ -107,6 +126,8 @@ func downloadWithRetry(url, name string) error {
 		if err != nil {
 			lastErr = fmt.Errorf("request failed: %w", err)
 			slog.Warn("Download attempt failed", "file", name, "attempt", attempt, "error", err)
+			// 传输中断会在输出文件里留下残缺内容，删掉避免被当作下载成功覆盖现有数据库
+			os.Remove(filepath.Join("./tmp", name))
 			time.Sleep(time.Duration(attempt) * time.Second)
 			continue
 		}
@@ -205,3 +226,64 @@ func gunzipFile(src, dst string) error {
 
 	return nil
 }
+
+// unzipFile 解压 zip 中与目标同名（或同后缀）的文件到 dst（dst 如 ./IP2LOCATION-LITE-DB11.IPV6.BIN）；
+// 找不到匹配文件时回退解压第一个非目录文件。
+func unzipFile(src, dst string) error {
+	r, err := zip.OpenReader(src)
+	if err != nil {
+		return err
+	}
+	defer r.Close()
+
+	target := filepath.Base(dst)
+	var fallback *zip.File
+	for _, f := range r.File {
+		if f.FileInfo().IsDir() {
+			continue
+		}
+		if fallback == nil {
+			fallback = f
+		}
+		if f.Name == target || strings.EqualFold(f.Name, target) || strings.HasSuffix(strings.ToLower(f.Name), strings.ToLower(target)) {
+			return extractZipEntry(f, dst)
+		}
+	}
+	if fallback == nil {
+		return fmt.Errorf("no file found in zip archive %s", src)
+	}
+	return extractZipEntry(fallback, dst)
+}
+
+func extractZipEntry(f *zip.File, dst string) error {
+	rc, err := f.Open()
+	if err != nil {
+		return err
+	}
+	defer rc.Close()
+
+	tmp := dst + ".tmp"
+	out, err := os.Create(tmp)
+	if err != nil {
+		return err
+	}
+	if _, err := io.Copy(out, rc); err != nil {
+		out.Close()
+		os.Remove(tmp)
+		return err
+	}
+	if err := out.Sync(); err != nil {
+		out.Close()
+		os.Remove(tmp)
+		return err
+	}
+	if err := out.Close(); err != nil {
+		os.Remove(tmp)
+		return err
+	}
+	if err := os.Rename(tmp, dst); err != nil {
+		os.Remove(tmp)
+		return err
+	}
+	return nil
+}

src/ipdb/searchip.go

@@ -15,6 +15,7 @@ import (
 	"time"
 
 	ipdbgo "github.com/ipipdotnet/ipdb-go"
+	"github.com/ip2location/ip2location-go/v9"
 	"github.com/lionsoul2014/ip2region/binding/golang/service"
 	maxminddb "github.com/oschwald/maxminddb-golang/v2"
 	"resty.dev/v3"
@@ -23,6 +24,10 @@ import (
 var (
 	ip2region     *service.Ip2Region
 	ip2regionMu   sync.RWMutex
+	ip2locDB      *ip2location.DB
+	ip2locMu      sync.RWMutex
+	ip2locASNDB   *ip2location.DB
+	ip2locASNMu   sync.RWMutex
 	qqwryDB       *ipdbgo.City
 	qqwryMu       sync.RWMutex
 	mmdbDBs       map[string]*maxminddb.Reader
@@ -163,7 +168,6 @@ func loadIp2Region() error {
 		ip2region.Close()
 		slog.Info("Previous ip2region closed")
 	}
-
 	v4Config, err := service.NewV4Config(service.VIndexCache, "ip2region_v4.xdb", 20)
 	if err != nil {
 		slog.Error("failed to create v4 config", "error", err)
@@ -186,6 +190,48 @@ func loadIp2Region() error {
 	return nil
 }
 
+// loadIP2Location 加载 IP2Location LITE DB11 数据库（.BIN 格式，官方 ip2location-go 库读取）
+func loadIP2Location() error {
+	ip2locMu.Lock()
+	defer ip2locMu.Unlock()
+
+	if ip2locDB != nil {
+		ip2locDB.Close()
+		ip2locDB = nil
+		slog.Info("Previous ip2location closed")
+	}
+
+	db, err := ip2location.OpenDB("./IP2LOCATION-LITE-DB11.IPV6.BIN")
+	if err != nil {
+		slog.Error("failed to open ip2location db", "error", err)
+		return err
+	}
+	ip2locDB = db
+	slog.Info("ip2location loaded successfully")
+	return nil
+}
+
+// loadIP2LocationASN 加载 IP2Location LITE ASN 数据库（仅 asn / as 字段）
+func loadIP2LocationASN() error {
+	ip2locASNMu.Lock()
+	defer ip2locASNMu.Unlock()
+
+	if ip2locASNDB != nil {
+		ip2locASNDB.Close()
+		ip2locASNDB = nil
+		slog.Info("Previous ip2location asn closed")
+	}
+
+	db, err := ip2location.OpenDB("./IP2LOCATION-LITE-ASN.IPV6.BIN")
+	if err != nil {
+		slog.Error("failed to open ip2location asn db", "error", err)
+		return err
+	}
+	ip2locASNDB = db
+	slog.Info("ip2location asn loaded successfully")
+	return nil
+}
+
 func loadQQWry() error {
 	qqwryMu.Lock()
 	defer qqwryMu.Unlock()
@@ -503,7 +549,7 @@ func searchBilibili(ip string) (*BilibiliResult, error) {
 		bilibiliCache.Delete(ip)
 	}
 
-	client := resty.New()
+	client := resty.New().SetTimeout(10 * time.Second)
 	defer client.Close()
 	resp, err := client.R().
 		SetQueryParam("ip", ip).
@@ -529,6 +575,18 @@ func searchBilibili(ip string) (*BilibiliResult, error) {
 	return result, nil
 }
 
+// SweepBilibiliCache 清理过期的 Bilibili 归属地缓存（由外部定时调用，
+// 防止公网端点被唯一 key 洪打时缓存内存无限增长）
+func SweepBilibiliCache() {
+	cutoff := time.Now().Add(-24 * time.Hour)
+	bilibiliCache.Range(func(k, v any) bool {
+		if e, ok := v.(bilibiliCacheEntry); ok && e.timestamp.Before(cutoff) {
+			bilibiliCache.Delete(k)
+		}
+		return true
+	})
+}
+
 func loadAll() {
 	if err := loadIp2Region(); err != nil {
 		slog.Error("Error loading ip2region", "error", err)
@@ -552,6 +610,20 @@ func closeAllDBs() {
 	}
 	ip2regionMu.Unlock()
 
+	ip2locMu.Lock()
+	if ip2locDB != nil {
+		ip2locDB.Close()
+		ip2locDB = nil
+	}
+	ip2locMu.Unlock()
+
+	ip2locASNMu.Lock()
+	if ip2locASNDB != nil {
+		ip2locASNDB.Close()
+		ip2locASNDB = nil
+	}
+	ip2locASNMu.Unlock()
+
 	qqwryMu.Lock()
 	qqwryDB = nil
 	qqwryMu.Unlock()
@@ -569,6 +641,12 @@ func reloadAll() {
 	if err := loadIp2Region(); err != nil {
 		slog.Error("Error loading ip2region", "error", err)
 	}
+	if err := loadIP2Location(); err != nil {
+		slog.Error("Error loading ip2location", "error", err)
+	}
+	if err := loadIP2LocationASN(); err != nil {
+		slog.Error("Error loading ip2location asn", "error", err)
+	}
 	if err := reloadQQWry(); err != nil {
 		slog.Error("Error reloading qqwry.ipdb", "error", err)
 	}
@@ -587,6 +665,14 @@ func Init(ghproxy string) {
 		slog.Warn("Local ip2region not available", "error", err)
 		localOK = false
 	}
+	if err := loadIP2Location(); err != nil {
+		slog.Warn("Local ip2location not available", "error", err)
+		localOK = false
+	}
+	if err := loadIP2LocationASN(); err != nil {
+		slog.Warn("Local ip2location asn not available", "error", err)
+		localOK = false
+	}
 	if err := loadQQWry(); err != nil {
 		slog.Warn("Local qqwry.ipdb not available", "error", err)
 		localOK = false
@@ -627,7 +713,7 @@ func Init(ghproxy string) {
 	}()
 }
 
-var allDatabases = []string{"ip2region", "qqwry", "maxmind_city", "maxmind_asn", "dbip_asn", "geocn", "dbip_city", "bilibili"}
+var allDatabases = []string{"ip2region", "ip2location", "ip2location_asn", "qqwry", "maxmind_city", "maxmind_asn", "dbip_asn", "geocn", "dbip_city", "bilibili"}
 
 func SearchIP(ip string, databases ...string) map[string]interface{} {
 	if len(databases) == 0 {
@@ -645,13 +731,74 @@ func SearchIP(ip string, databases ...string) map[string]interface{} {
 				if err != nil {
 					result["ip2region"] = "error: " + err.Error()
 				} else {
-					result["ip2region"] = region
+					// 预分割为结构化 JSON，前端无需再按 "|" 拆字符串
+					result["ip2region"] = parseIP2Region(region)
 				}
 			} else {
 				result["ip2region"] = "not loaded"
 			}
 			ip2regionMu.RUnlock()
 
+		case "ip2location":
+			ip2locMu.RLock()
+			if ip2locDB != nil {
+				rec, err := ip2locDB.Get_all(ip)
+				if err != nil {
+					result["ip2location"] = "error: " + err.Error()
+				} else {
+					// LITE 免费版不提供 asn/isp 等字段，库会返回占位提示串，统一过滤为空
+					clean := func(s string) string {
+						if s == "" || strings.HasPrefix(s, "This parameter is unavailable") {
+							return ""
+						}
+						return s
+					}
+					loc := map[string]string{
+						"country":             clean(rec.Country_long),
+						"country_code":        clean(rec.Country_short),
+						"administrative_area": clean(rec.Region),
+						"city":                clean(rec.City),
+						"isp":                 clean(rec.Isp),
+						"asn":                 clean(rec.Asn),
+						"district":            clean(rec.District),
+						"zipcode":             clean(rec.Zipcode),
+						"timezone":            clean(rec.Timezone),
+						"usagetype":           clean(rec.Usagetype),
+					}
+					if rec.Latitude != 0 || rec.Longitude != 0 {
+						loc["latitude"] = strconv.FormatFloat(float64(rec.Latitude), 'f', -1, 32)
+						loc["longitude"] = strconv.FormatFloat(float64(rec.Longitude), 'f', -1, 32)
+					}
+					result["ip2location"] = loc
+				}
+			} else {
+				result["ip2location"] = "not loaded"
+			}
+			ip2locMu.RUnlock()
+
+		case "ip2location_asn":
+			ip2locASNMu.RLock()
+			if ip2locASNDB != nil {
+				rec, err := ip2locASNDB.Get_all(ip)
+				if err != nil {
+					result["ip2location_asn"] = "error: " + err.Error()
+				} else {
+					clean := func(s string) string {
+						if s == "" || strings.HasPrefix(s, "This parameter is unavailable") {
+							return ""
+						}
+						return s
+					}
+					result["ip2location_asn"] = map[string]string{
+						"asn": clean(rec.Asn),
+						"as":  clean(rec.As),
+					}
+				}
+			} else {
+				result["ip2location_asn"] = "not loaded"
+			}
+			ip2locASNMu.RUnlock()
+
 		case "qqwry":
 			qqwryMu.RLock()
 			if qqwryDB != nil {
@@ -727,3 +874,28 @@ func SearchIP(ip string, databases ...string) map[string]interface{} {
 
 	return result
 }
+
+// parseIP2Region 将 ip2region xdb 的管道分隔串预分割为结构化 JSON。
+// 实测 v4/v6 xdb 格式：国家|省份|城市|ISP(或"0")|国家代码（5 段，v4 的 ISP 段多为 "0"）；
+// 兼容老 4 段格式：国家|省份|城市|ISP。
+// 输出字段与 bilibili / geocn / maxmind_city 对齐：country / administrative_area / city / isp。
+func parseIP2Region(s string) map[string]string {
+	parts := strings.Split(s, "|")
+	for i := range parts {
+		parts[i] = strings.TrimSpace(parts[i])
+	}
+	get := func(i int) string {
+		if i < len(parts) {
+			return parts[i]
+		}
+		return ""
+	}
+	res := map[string]string{"country": get(0)}
+	// 5 段：国家|省份|城市|ISP(可能为"0")|国家代码；4 段及以下：国家|省份|城市|ISP
+	res["administrative_area"] = get(1)
+	res["city"] = get(2)
+	if isp := get(3); isp != "" && isp != "0" {
+		res["isp"] = isp
+	}
+	return res
+}

src/main.go

@@ -4,6 +4,7 @@ import (
 	"context"
 	"crypto/tls"
 	"encoding/json"
+	"errors"
 	"fmt"
 	"io"
 	"lemon-ipw/ipdb"
@@ -14,11 +15,15 @@ import (
 	"net/http"
 	"net/url"
 	"os"
+	"os/signal"
+	"runtime"
 	"strconv"
 	"strings"
 	"sync"
+	"syscall"
 	"time"
 
+	"github.com/AdguardTeam/golibs/netutil/sysresolv"
 	"github.com/gin-contrib/cors"
 	"github.com/gin-gonic/gin"
 	"github.com/klauspost/compress/zstd"
@@ -214,33 +219,40 @@ func (s *Setting) PortString() string {
 // Global variables and structs
 // 全局变量与结构体
 var (
-	PORTS          string
-	GH_PROXY       string
-	LOG_LEVEL      string
-	websiteCache   sync.Map
-	SINGLE_STACK   string
-	DNS_SERVER     string
-	DNSSEC_DNS_SERVER string // DNSSEC 专用 DNS 服务器（dnssec-server / DNSSEC_DNS_SERVER），留空沿用 DNS_SERVER
-	sslCache       sync.Map
-	pingCache      sync.Map
-	speedCache     sync.Map
-	whoisCache     sync.Map
-	asnWhoisCache  sync.Map
-	sfGroup        singleflight.Group
-	V6Client       *resty.Client
-	V4Client       *resty.Client
-	IPDB           string
-	CORS           string
-	ACCEPT_DOMAINS     []string
-	ACCESS_TOKEN       string
-	REMOTE_CONFIG_URL  string
-	REMOTE_INGORE_CONFIG []string // 不被远端配置覆盖的配置项列表（remote-ingore-config / REMOTE_INGORE_CONFIG）
-	WS_URL             string // WS 客户端：中间件 WS 地址（ws://host:port/ws）
-	WS_NODE_ID         string // WS 客户端：节点 id（与中间件 apiKeys 键一致）
-	WS_NODE_KEY        string // WS 客户端：注册 key（与中间件 apiKeys[节点id] 一致，可空）
-	VERSION            string
-	COMMIT             string
-	BUILD_TIME         string
+	PORTS                string
+	GH_PROXY             string
+	LOG_LEVEL            string
+	websiteCache         sync.Map
+	SINGLE_STACK         string
+	DNS_SERVER           string
+	DNSSEC_DNS_SERVER    string // DNSSEC 专用 DNS 服务器（dnssec-server / DNSSEC_DNS_SERVER），留空沿用 DNS_SERVER
+	sslCache             sync.Map
+	pingCache            sync.Map
+	speedCache           sync.Map
+	whoisCache           sync.Map
+	asnWhoisCache        sync.Map
+	sfGroup              singleflight.Group
+	V6Client             *resty.Client
+	V4Client             *resty.Client
+	IPDB                 string
+	CORS                 string
+	ACCEPT_DOMAINS       []string
+	ACCESS_TOKEN         string
+	REMOTE_CONFIG_URL    string
+	REMOTE_IGNORE_CONFIG []string      // 不被远端配置覆盖的配置项列表（remote-ignore-config / REMOTE_IGNORE_CONFIG）
+	WS_URL               string        // WS 客户端：中间件 WS 地址（ws://host:port/ws）
+	WS_NODE_ID           string        // WS 客户端：节点 id（与中间件 ws-keys 键一致）
+	WS_NODE_KEY          string        // WS 客户端：注册 key（与中间件 ws-keys[节点id] 一致，可空）
+	REPORT_URL           string        // 数据上报：收集中心 HTTP 接口基址（report-url / REPORT_URL），WS 全部掉线时的兜底通道
+	REPORT_TOKEN         string        // 数据上报：/report 鉴权 token（report-token / REPORT_TOKEN）
+	REPORT_INTERVAL      int           // 数据上报间隔秒（report-interval-seconds / REPORT_INTERVAL_SECONDS），缺省 15
+	NODE_OTA             string        // OTA 自更新开关（node-ota / NODE_OTA），"true" 时启用
+	TRUSTED_PROXIES      string        // 可信代理列表（trusted-proxies / TRUSTED_PROXIES），逗号分隔 IP/CIDR，供 ClientIP 判定
+	httpServer           *http.Server  // 显式持有的 HTTP 服务（Windows OTA 优雅重启需要先 Shutdown）
+	otaHandoverWait      chan struct{} // 非 nil 表示 Windows OTA 优雅重启模式：Serve 关闭后 main 停在此等待老进程退出
+	VERSION              string
+	COMMIT               string
+	BUILD_TIME           string
 )
 
 type websiteCacheEntry struct {
@@ -278,8 +290,6 @@ type WebsiteCheckResult struct {
 	IPv6 *webtest.WebsiteCheckDetail `json:"ipv6"`
 }
 
-
-
 type SSLCheckResult struct {
 	IPv4 *webtest.SSLCheckDetail `json:"ipv4"`
 	IPv6 *webtest.SSLCheckDetail `json:"ipv6"`
@@ -292,10 +302,6 @@ type TCPingResult struct {
 // Business Endpoints
 // 业务端点
 
-
-
-
-
 func checkWebsiteHandler(c *gin.Context) {
 	testUrl := c.Param("url")
 	if testUrl == "" {
@@ -307,8 +313,8 @@ func checkWebsiteHandler(c *gin.Context) {
 
 	testUrl = normalizeURL(testUrl)
 
-	parsedURL, _ := url.Parse(testUrl)
-	if ssrf.HasLocalOrPrivateIP(parsedURL.Hostname()) {
+	parsedURL, err := url.Parse(testUrl)
+	if err == nil && ssrf.HasLocalOrPrivateIP(parsedURL.Hostname()) {
 		c.JSON(200, &WebsiteCheckResult{
 			IPv4: fakePerfectWebsiteResult(testUrl),
 			IPv6: fakePerfectWebsiteResult(testUrl),
@@ -387,7 +393,17 @@ func checkWebsiteHandler(c *gin.Context) {
 
 		websiteCache.Store(testUrl, websiteCacheEntry{result: result, timestamp: time.Now()})
 
-		if (result.IPv4 != nil && !result.IPv4.IsReachable) || (result.IPv6 != nil && !result.IPv6.IsReachable) {
+		// 单栈模式下被跳过的一侧 IsReachable 恒为 false，不能据此把成功结果也判定为失败提前清缓存
+		failed := false
+		switch SINGLE_STACK {
+		case "ipv4":
+			failed = result.IPv4 != nil && !result.IPv4.IsReachable
+		case "ipv6":
+			failed = result.IPv6 != nil && !result.IPv6.IsReachable
+		default:
+			failed = (result.IPv4 != nil && !result.IPv4.IsReachable) || (result.IPv6 != nil && !result.IPv6.IsReachable)
+		}
+		if failed {
 			go func() {
 				time.Sleep(30 * time.Second)
 				websiteCache.Delete(testUrl)
@@ -485,8 +501,8 @@ func sslCheckHandler(c *gin.Context) {
 
 	testUrl = normalizeURL(testUrl)
 
-	parsedURL, _ := url.Parse(testUrl)
-	if ssrf.HasLocalOrPrivateIP(parsedURL.Hostname()) {
+	parsedURL, err := url.Parse(testUrl)
+	if err == nil && ssrf.HasLocalOrPrivateIP(parsedURL.Hostname()) {
 		c.JSON(200, &SSLCheckResult{
 			IPv4: fakeInvalidSSLResult(parsedURL.Hostname()),
 			IPv6: fakeInvalidSSLResult(parsedURL.Hostname()),
@@ -571,7 +587,17 @@ func sslCheckHandler(c *gin.Context) {
 
 		sslCache.Store(testUrl, sslCacheEntry{result: result, timestamp: time.Now()})
 
-		if (result.IPv4 != nil && !result.IPv4.IsReachable) || (result.IPv6 != nil && !result.IPv6.IsReachable) {
+		// 单栈模式下被跳过的一侧 IsReachable 恒为 false，不能据此把成功结果也判定为失败提前清缓存
+		failed := false
+		switch SINGLE_STACK {
+		case "ipv4":
+			failed = result.IPv4 != nil && !result.IPv4.IsReachable
+		case "ipv6":
+			failed = result.IPv6 != nil && !result.IPv6.IsReachable
+		default:
+			failed = (result.IPv4 != nil && !result.IPv4.IsReachable) || (result.IPv6 != nil && !result.IPv6.IsReachable)
+		}
+		if failed {
 			go func() {
 				time.Sleep(30 * time.Second)
 				sslCache.Delete(testUrl)
@@ -605,12 +631,23 @@ func asnLookupHandler(c *gin.Context) {
 		return
 	}
 
-	result := ipdb.SearchIP(ip, "maxmind_asn", "dbip_asn")
+	result := ipdb.SearchIP(ip, "maxmind_asn", "dbip_asn", "ip2location_asn")
 
 	asnResult := map[string]interface{}{
 		"ip": ip,
 	}
 
+	if ip2locASN, ok := result["ip2location_asn"].(map[string]string); ok && ip2locASN["asn"] != "" {
+		asnResult["ip2location_asn"] = map[string]string{
+			"asn": ip2locASN["asn"],
+			"as":  ip2locASN["as"],
+		}
+	} else if errStr, ok := result["ip2location_asn"].(string); ok {
+		asnResult["ip2location_asn"] = map[string]string{
+			"error": errStr,
+		}
+	}
+
 	if maxmindASN, ok := result["maxmind_asn"].(*ipdb.MMDBASNResult); ok {
 		asnResult["geolite2_asn"] = map[string]string{
 			"asn": maxmindASN.ASN,
@@ -825,6 +862,8 @@ func pingHandler(c *gin.Context) {
 		})
 		return
 	}
+	// 拨号用归一化后的端口：Atoi 会放行 "+80"/"0080"，原样拼接会导致拨号必败
+	port = strconv.Itoa(portNum)
 
 	count := 4
 	if countStr := c.Query("count"); countStr != "" {
@@ -935,6 +974,7 @@ func tokenCheck() gin.HandlerFunc {
 		}
 	}
 }
+
 // fetchRemoteConfig 从远端 URL 拉取配置文件（遵守 setting.json 的 JSON 格式）。
 // 拉取或解析失败时返回错误，调用方应回退到本地配置。
 func fetchRemoteConfig(url string) (map[string]any, error) {
@@ -980,7 +1020,7 @@ func configValue(CONFIG map[string]any, key string) string {
 // applyRemoteConfig 从远端配置 URL（REMOTE_CONFIG_URL，可由环境变量或 setting.json
 // 的 remote-config-url 提供）拉取配置并覆盖本地配置。
 // 优先级：远端配置 > 环境变量 > setting.json。
-// access_token 例外：保持原有优先级（环境变量 > setting.json），不随远端配置覆盖。
+// access-token 例外：保持原有优先级（环境变量 > setting.json），不随远端配置覆盖。
 func applyRemoteConfig() {
 	url := REMOTE_CONFIG_URL
 	if url == "" {
@@ -993,7 +1033,7 @@ func applyRemoteConfig() {
 	}
 	// ignore 列表：数组中的配置项不被远端覆盖（逐键判断跳过）
 	ignored := func(key string) bool {
-		for _, k := range REMOTE_INGORE_CONFIG {
+		for _, k := range REMOTE_IGNORE_CONFIG {
 			if k == key {
 				return true
 			}
@@ -1035,9 +1075,21 @@ func applyRemoteConfig() {
 	if v := configValue(CONFIG, "node-key"); v != "" && !ignored("node-key") {
 		WS_NODE_KEY = v
 	}
-	// access_token 不在此覆盖：保持原有优先级（环境变量 > setting.json）
+	// 数据上报收集中心（远端可统一下发；report-token 属凭据，不随远端覆盖）
+	if v := configValue(CONFIG, "report-url"); v != "" && !ignored("report-url") {
+		REPORT_URL = v
+	}
+	// OTA 自更新开关（远端可统一开启/关闭节点的自更新）
+	if v := configValue(CONFIG, "node-ota"); v != "" && !ignored("node-ota") {
+		NODE_OTA = v
+	}
+	// 可信代理列表（远端可统一下发）
+	if v := configValue(CONFIG, "trusted-proxies"); v != "" && !ignored("trusted-proxies") {
+		TRUSTED_PROXIES = v
+	}
+	// access-token 不在此覆盖：保持原有优先级（环境变量 > setting.json）
 	if CORS != "" {
-		ACCEPT_DOMAINS = strings.Split(CORS, ",")
+		ACCEPT_DOMAINS = splitAndTrim(CORS, ",")
 	}
 	slog.Info("Remote config applied", "url", url)
 }
@@ -1054,6 +1106,7 @@ func readConfig() {
 	IPDB = os.Getenv("IPDB")
 	CORS = os.Getenv("CORS")
 	ACCESS_TOKEN = os.Getenv("ACCESS_TOKEN")
+	TRUSTED_PROXIES = os.Getenv("TRUSTED_PROXIES")
 	ssrf.SetEnabled(os.Getenv("BLOCK_PRIVATE_IPS") != "false" && os.Getenv("BLOCK_PRIVATE_IPS") != "0")
 
 	// SINGLE_STACK is intentionally excluded: empty string is a valid value (dual-stack).
@@ -1085,14 +1138,17 @@ func readConfig() {
 	if CORS == "" {
 		CORS = viper.GetString("cors")
 	}
+	if TRUSTED_PROXIES == "" {
+		TRUSTED_PROXIES = viper.GetString("trusted-proxies")
+	}
 	if PORTS == "" {
 		PORTS = "8080"
 	}
 	if CORS != "" {
-		ACCEPT_DOMAINS = strings.Split(CORS, ",")
+		ACCEPT_DOMAINS = splitAndTrim(CORS, ",")
 	}
 	if ACCESS_TOKEN == "" {
-		ACCESS_TOKEN = viper.GetString("access_token")
+		ACCESS_TOKEN = viper.GetString("access-token")
 	}
 	// REMOTE_CONFIG_URL 优先级：环境变量 > setting.json 的 remote-config-url
 	REMOTE_CONFIG_URL = os.Getenv("REMOTE_CONFIG_URL")
@@ -1112,21 +1168,111 @@ func readConfig() {
 	if WS_NODE_KEY == "" {
 		WS_NODE_KEY = viper.GetString("node-key")
 	}
-	// REMOTE_INGORE_CONFIG：不被远端覆盖的配置项列表（JSON 数组字符串，env 优先）
-	if raw := os.Getenv("REMOTE_INGORE_CONFIG"); raw != "" {
+	// 数据上报（report-url / report-token / report-interval-seconds），env 优先；详见 report.go
+	REPORT_URL = os.Getenv("REPORT_URL")
+	if REPORT_URL == "" {
+		REPORT_URL = viper.GetString("report-url")
+	}
+	REPORT_TOKEN = os.Getenv("REPORT_TOKEN")
+	if REPORT_TOKEN == "" {
+		REPORT_TOKEN = viper.GetString("report-token")
+	}
+	REPORT_INTERVAL = viper.GetInt("report-interval-seconds")
+	if v := os.Getenv("REPORT_INTERVAL_SECONDS"); v != "" {
+		if n, err := strconv.Atoi(v); err == nil && n > 0 {
+			REPORT_INTERVAL = n
+		}
+	} else if REPORT_INTERVAL <= 0 {
+		REPORT_INTERVAL = 15
+	}
+	// NODE_OTA：OTA 自更新开关（环境变量 NODE_OTA 或 setting.json 的 node-ota）
+	NODE_OTA = os.Getenv("NODE_OTA")
+	if NODE_OTA == "" {
+		NODE_OTA = viper.GetString("node-ota")
+	}
+	// REMOTE_IGNORE_CONFIG：不被远端覆盖的配置项列表（JSON 数组字符串，env 优先）
+	if raw := os.Getenv("REMOTE_IGNORE_CONFIG"); raw != "" {
 		var list []string
 		if err := json.Unmarshal([]byte(raw), &list); err == nil {
-			REMOTE_INGORE_CONFIG = list
+			REMOTE_IGNORE_CONFIG = list
 		} else {
-			slog.Warn("invalid REMOTE_INGORE_CONFIG, ignored", "error", err)
+			slog.Warn("invalid REMOTE_IGNORE_CONFIG, ignored", "error", err)
 		}
 	} else {
-		REMOTE_INGORE_CONFIG = viper.GetStringSlice("remote-ingore-config")
+		REMOTE_IGNORE_CONFIG = viper.GetStringSlice("remote-ignore-config")
 	}
 	applyRemoteConfig()
+	var SYSTEM_DNS string
+	if DNS_SERVER == "" || DNSSEC_DNS_SERVER == "" {
+		sysDNS, err := sysresolv.NewSystemResolvers(nil, 53)
+		if err != nil {
+			// 失败时 sysDNS 为 nil，绝不能再调用 Refresh()，否则启动即 panic；
+			// SYSTEM_DNS 留空，交给下游的内置默认 DNS 兜底
+			slog.Warn("Cannot setup system resolvers, DNS_SERVER will fall back to webtest defaults", "error", err)
+		} else {
+			sysDNS.Refresh()
+			SYSTEM_DNS = webtest.AddrPortsToCSV(sysDNS.Addrs())
+		}
+	}
+	if DNSSEC_DNS_SERVER == "" {
+		DNSSEC_DNS_SERVER = SYSTEM_DNS
+	}
+	if DNS_SERVER == "" {
+		DNS_SERVER = SYSTEM_DNS
+	}
 	slog.Info("SSRF protection initialized", "blockPrivateIPs", ssrf.Enabled())
 }
 
+// splitAndTrim 按逗号切分并去掉每段首尾空白：CORS 配置 "a.com, b.com" 带空格时，
+// 直接 Split 会产生带前导空格的 origin，永远匹配不上请求头
+func splitAndTrim(s, sep string) []string {
+	parts := strings.Split(s, sep)
+	out := make([]string, 0, len(parts))
+	for _, p := range parts {
+		if p = strings.TrimSpace(p); p != "" {
+			out = append(out, p)
+		}
+	}
+	return out
+}
+
+// sweepExpiredCaches 按条目时间戳清扫各 sync.Map 缓存（TTL 均为 5 分钟，清扫窗口取 10 分钟）
+func sweepExpiredCaches() {
+	cutoff := time.Now().Add(-10 * time.Minute)
+	sweep := func(m *sync.Map) {
+		m.Range(func(k, v any) bool {
+			var ts time.Time
+			switch e := v.(type) {
+			case websiteCacheEntry:
+				ts = e.timestamp
+			case sslCacheEntry:
+				ts = e.timestamp
+			case pingCacheEntry:
+				ts = e.timestamp
+			case speedCacheEntry:
+				ts = e.timestamp
+			case whoisCacheEntry:
+				ts = e.timestamp
+			case asnWhoisCacheEntry:
+				ts = e.timestamp
+			default:
+				return true
+			}
+			if ts.Before(cutoff) {
+				m.Delete(k)
+			}
+			return true
+		})
+	}
+	sweep(&websiteCache)
+	sweep(&sslCache)
+	sweep(&pingCache)
+	sweep(&speedCache)
+	sweep(&whoisCache)
+	sweep(&asnWhoisCache)
+	ipdb.SweepBilibiliCache()
+}
+
 func main() {
 	for _, vaule := range os.Args {
 		if vaule == "-v" || vaule == "--version" || vaule == "version" {
@@ -1156,7 +1302,35 @@ func main() {
 		slog.Info("WS client enabled", "url", WS_URL, "nodeId", WS_NODE_ID)
 	}
 
+	// 数据上报：WS 在线走 WS 广播，否则 HTTP POST 收集中心 /report（详见 report.go）
+	startNodeReporter()
+
+	// OTA 自更新：定期检查 GitHub Release 并替换二进制（配置 NODE_OTA / node-ota 启用）
+	initOTA(GH_PROXY)
+
+	// 缓存清扫：各 sync.Map 只在同 key 重访时惰性淘汰过期条目，
+	// 公网端点被唯一 key 洪打时内存会无限增长，这里定期清扫
+	go func() {
+		for {
+			time.Sleep(10 * time.Minute)
+			sweepExpiredCaches()
+		}
+	}()
+
 	r := gin.Default()
+	// TRUSTED_PROXIES / trusted-proxies：逗号分隔的可信代理（IP/CIDR）。配置后 ClientIP 只信任这些
+	// 代理转发的 X-Forwarded-For；未配置时保持 gin 默认行为（信任所有代理）
+	if strings.TrimSpace(TRUSTED_PROXIES) != "" {
+		var proxies []string
+		for _, p := range strings.Split(TRUSTED_PROXIES, ",") {
+			if p = strings.TrimSpace(p); p != "" {
+				proxies = append(proxies, p)
+			}
+		}
+		if err := r.SetTrustedProxies(proxies); err != nil {
+			slog.Warn("Invalid TRUSTED_PROXIES, keep gin default", "error", err)
+		}
+	}
 	corsConfig := cors.DefaultConfig()
 
 	if len(ACCEPT_DOMAINS) > 0 {
@@ -1170,6 +1344,7 @@ func main() {
 	if ACCESS_TOKEN != "" {
 		v1.Use(tokenCheck()) // Apply token check middleware to the v1 group
 	}
+	v1.Use(nodeReportMiddleware()) // 数据上报统计：归属规则过滤后计数（详见 report.go）
 	{
 		v1.GET("/detail/*url", checkWebsiteHandler)
 		v1.GET("/ssl/*url", sslCheckHandler)
@@ -1188,7 +1363,48 @@ func main() {
 
 	r.GET("/", healchCheck)
 
-	if err := r.Run(":" + PORTS); err != nil {
+	// 显式持有 http.Server：Windows OTA 优雅重启需要先 Shutdown 释放端口再拉起新进程，
+	// 避免 r.Run 的隐式 Server 无法受控关闭、父子进程抢端口
+	httpServer = &http.Server{Handler: r}
+	ln, err := net.Listen("tcp", ":"+PORTS)
+	if err != nil {
 		slog.Error("Server failed to start", "error", err)
+		os.Exit(1)
+	}
+	go func() {
+		// 优雅重启时 Shutdown 会正常关闭 Server，返回 ErrServerClosed 属预期
+		if err := httpServer.Serve(ln); err != nil && !errors.Is(err, http.ErrServerClosed) {
+			slog.Error("Server failed to start", "error", err)
+			os.Exit(1)
+		}
+	}()
+
+	// Windows OTA：Server 被 restartSelf 的优雅停机关闭后，main 停在这里不退出，
+	// 由 restartSelf 在新进程健康检查通过后 os.Exit 结束整个老进程
+	if otaEnabled() && runtime.GOOS == "windows" {
+		otaHandoverWait = make(chan struct{})
+		<-otaHandoverWait
+		return
+	}
+	// 非 OTA 交接模式：main 必须阻塞，否则 Server goroutine 随 main 返回而消亡，
+	// 进程启动后立即退出。阻塞在退出信号上，收到后走优雅停机。
+	sigCh := make(chan os.Signal, 1)
+	signal.Notify(sigCh, os.Interrupt, syscall.SIGTERM)
+	<-sigCh
+	gracefulShutdown()
+}
+
+// gracefulShutdown 优雅停止 HTTP 服务：停止接收新请求，等待在途请求完成（上限 30s）。
+// 供 Windows OTA 在拉起新进程前调用，确保监听端口先释放、子进程能正常绑定。
+func gracefulShutdown() {
+	if httpServer == nil {
+		return
+	}
+	ctx, cancel := context.WithTimeout(context.Background(), 30*time.Second)
+	defer cancel()
+	slog.Info("Graceful shutdown started, waiting for in-flight requests")
+	if err := httpServer.Shutdown(ctx); err != nil {
+		slog.Warn("Graceful shutdown timed out, forcing close", "error", err)
+		httpServer.Close()
 	}
 }

src/ota.go

@@ -0,0 +1,436 @@
+package main
+
+import (
+	"context"
+	"encoding/json"
+	"fmt"
+	"log/slog"
+	"math/rand"
+	"net/http"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"runtime"
+	"strconv"
+	"strings"
+	"sync"
+	"syscall"
+	"time"
+
+	"resty.dev/v3"
+)
+
+// OTA 自更新：定期检查 GitHub Release，下载与当前平台匹配的新版二进制替换自身并重启。
+// 默认关闭，需显式开启（环境变量 NODE_OTA 或 setting.json 的 node-ota）。
+
+const (
+	otaReleaseAPI    = "https://api.github.com/repos/nomdn/ipw-cn/releases/latest"
+	otaFirstDelay    = 5 * time.Minute // 启动后首次检查的延迟（避免与数据库下载冲突）
+	otaCheckInterval = 6 * time.Hour   // 常规检查间隔
+	otaMinSize       = 1 * 1024 * 1024 // 下载文件最小体积，防止拿到错误页/占位文件
+)
+
+var (
+	otaMu      sync.Mutex
+	otaLastRun time.Time
+)
+
+type otaRelease struct {
+	TagName string `json:"tag_name"`
+	Assets  []struct {
+		Name               string `json:"name"`
+		BrowserDownloadURL string `json:"browser_download_url"`
+		Size               int64  `json:"size"`
+	} `json:"assets"`
+}
+
+// otaEnabled 判断是否启用 OTA（"true" / "1" / "yes" / "on" 视为开启）
+func otaEnabled() bool {
+	switch strings.ToLower(strings.TrimSpace(NODE_OTA)) {
+	case "true", "1", "yes", "on":
+		return true
+	}
+	return false
+}
+
+// initOTA 在后台启动 OTA 检查循环，未启用时直接返回
+func initOTA(ghproxy string) {
+	if !otaEnabled() {
+		slog.Debug("OTA disabled")
+		return
+	}
+	slog.Info("OTA enabled", "current_version", VERSION, "check_interval", otaCheckInterval.String())
+
+	go func() {
+		// 首次延迟，避免启动瞬间与数据库下载抢占带宽或触发重启
+		time.Sleep(otaFirstDelay)
+		for {
+			checkOTAUpdate(ghproxy)
+			jitter := time.Duration(rand.Int63n(int64(time.Hour)))
+			time.Sleep(otaCheckInterval + jitter)
+		}
+	}()
+}
+
+// otaAssetNames 按优先级返回当前平台可能的发布资产名（与 build_and_release.yml 命名一致）
+func otaAssetNames() []string {
+	suffix := ""
+	if runtime.GOOS == "windows" {
+		suffix = ".exe"
+	}
+	arch := runtime.GOARCH
+	// GOARCH=arm 时无法在运行时区分 GOARM（armv7/armv6），依次尝试
+	if runtime.GOOS == "linux" && arch == "arm" {
+		return []string{
+			"lemonipw-linux-armv7",
+			"lemonipw-linux-armv6",
+			"lemonipw-linux-arm",
+		}
+	}
+	return []string{fmt.Sprintf("lemonipw-%s-%s%s", runtime.GOOS, arch, suffix)}
+}
+
+// compareVersion 比较版本号：latest > current 返回正数，相等返回 0，否则返回负数；
+// 非数字段按字典序比较。latest 为空（无法获取远端版本）时返回 0，不做更新。
+func compareVersion(latest, current string) int {
+	if strings.TrimSpace(latest) == "" {
+		return 0
+	}
+	trim := func(s string) string {
+		s = strings.TrimSpace(s)
+		s = strings.TrimPrefix(s, "v")
+		s = strings.TrimPrefix(s, "V")
+		if i := strings.IndexAny(s, "-+"); i >= 0 { // 忽略预发布后缀
+			s = s[:i]
+		}
+		return s
+	}
+	a := strings.Split(trim(latest), ".")
+	b := strings.Split(trim(current), ".")
+	for i := 0; i < len(a) || i < len(b); i++ {
+		var x, y int
+		var xe, ye error
+		if i < len(a) {
+			x, xe = strconv.Atoi(a[i])
+		}
+		if i < len(b) {
+			y, ye = strconv.Atoi(b[i])
+		}
+		switch {
+		case xe == nil && ye == nil:
+			if x != y {
+				return x - y
+			}
+		case xe == nil: // 只有当前版本非数字
+			return 1
+		case ye == nil:
+			return -1
+		default: // 两段都非数字，按字典序
+			if a[i] != b[i] {
+				if a[i] > b[i] {
+					return 1
+				}
+				return -1
+			}
+		}
+	}
+	return 0
+}
+
+// majorSame 判断 latest 与 current 的 major 段是否相同。
+// 任一段无法解析（如本地构建 VERSION 为空）时返回 true（放行，不拦截更新）。
+func majorSame(latest, current string) bool {
+	parseMajor := func(s string) (int, bool) {
+		s = strings.TrimSpace(s)
+		s = strings.TrimPrefix(s, "v")
+		s = strings.TrimPrefix(s, "V")
+		if i := strings.IndexAny(s, "-+."); i >= 0 {
+			s = s[:i]
+		}
+		n, err := strconv.Atoi(s)
+		if err != nil {
+			return 0, false
+		}
+		return n, true
+	}
+	lm, lok := parseMajor(latest)
+	cm, cok := parseMajor(current)
+	if !lok || !cok {
+		return true
+	}
+	return lm == cm
+}
+
+// fetchLatestRelease 查询 GitHub 最新 Release 信息
+func fetchLatestRelease() (*otaRelease, error) {
+	client := resty.New().SetTimeout(30 * time.Second)
+	defer client.Close()
+
+	resp, err := client.R().
+		SetHeader("Accept", "application/vnd.github+json").
+		SetHeader("User-Agent", "lemon-ipw-ota").
+		Get(otaReleaseAPI)
+	if err != nil {
+		return nil, err
+	}
+	if resp.IsError() {
+		return nil, fmt.Errorf("HTTP %d", resp.StatusCode())
+	}
+	var rel otaRelease
+	if err := json.Unmarshal(resp.Bytes(), &rel); err != nil {
+		return nil, err
+	}
+	if rel.TagName == "" {
+		return nil, fmt.Errorf("empty tag_name")
+	}
+	return &rel, nil
+}
+
+// findAssetURL 在 Release 资产中查找当前平台的下载链接，同时返回资产大小用于完整性校验
+func findAssetURL(rel *otaRelease) (string, string, int64) {
+	for _, want := range otaAssetNames() {
+		for _, a := range rel.Assets {
+			if a.Name == want {
+				return a.BrowserDownloadURL, a.Name, a.Size
+			}
+		}
+	}
+	return "", "", 0
+}
+
+// checkOTAUpdate 执行一次检查：有新版本则下载替换并重启
+func checkOTAUpdate(ghproxy string) {
+	otaMu.Lock()
+	defer otaMu.Unlock()
+	otaLastRun = time.Now()
+
+	rel, err := fetchLatestRelease()
+	if err != nil {
+		slog.Warn("OTA check failed", "error", err)
+		return
+	}
+
+	cmp := compareVersion(rel.TagName, VERSION)
+	if cmp <= 0 {
+		slog.Debug("OTA already up to date", "latest", rel.TagName, "current", VERSION)
+		return
+	}
+
+	// major 版本变化（如 3.x → 4.x）通常含破坏性变更，不自动更新，需人工升级
+	if !majorSame(rel.TagName, VERSION) {
+		slog.Warn("OTA skipped: major version upgrade requires manual action",
+			"latest", rel.TagName, "current", VERSION)
+		return
+	}
+
+	assetURL, assetName, assetSize := findAssetURL(rel)
+	if assetURL == "" {
+		slog.Warn("OTA no matching asset for this platform",
+			"tag", rel.TagName, "goos", runtime.GOOS, "goarch", runtime.GOARCH)
+		return
+	}
+
+	slog.Info("OTA new version found", "tag", rel.TagName, "current", VERSION, "asset", assetName)
+
+	exePath, err := os.Executable()
+	if err != nil {
+		slog.Error("OTA cannot locate executable", "error", err)
+		return
+	}
+	exePath, err = filepath.EvalSymlinks(exePath)
+	if err != nil {
+		slog.Error("OTA cannot resolve executable path", "error", err)
+		return
+	}
+
+	// 下载到同目录（保证与目标同分区，rename 原子替换），
+	// 临时文件使用远端资产名（如 lemonipw-linux-amd64）+ .tmp 后缀，避免与运行中的 exe 冲突
+	tmpPath := filepath.Join(filepath.Dir(exePath), assetName+".tmp")
+	if err := downloadOTA(ghproxy+assetURL, tmpPath, assetSize); err != nil {
+		slog.Error("OTA download failed", "error", err)
+		os.Remove(tmpPath)
+		return
+	}
+
+	// 预检：停机前先试运行新二进制（-v 打印版本即退出），确认文件可执行、架构匹配。
+	// 损坏/被杀毒隔离的文件若直到交接时才发现，子进程会秒退导致服务中断
+	if err := preflightBinary(tmpPath); err != nil {
+		slog.Error("OTA preflight failed, keep current version", "error", err)
+		os.Remove(tmpPath)
+		return
+	}
+
+	if err := replaceBinary(tmpPath, exePath); err != nil {
+		slog.Error("OTA replace failed", "error", err)
+		return
+	}
+
+	slog.Info("OTA binary replaced, restarting", "tag", rel.TagName)
+	restartSelf(exePath)
+}
+
+// downloadOTA 下载二进制到临时文件，并做体积校验（Release 声明的资产大小精确比对 + 最小体积兜底）。
+// 注意：GitHub Release 未提供签名/哈希清单，无法做内容级认证，体积校验只能防截断与错装文件。
+func downloadOTA(url, dst string, expectSize int64) error {
+	client := resty.New().SetTimeout(10 * time.Minute)
+	defer client.Close()
+
+	resp, err := client.R().SetOutputFileName(dst).SetSaveResponse(true).Get(url)
+	if err != nil {
+		return err
+	}
+	if resp.IsError() {
+		return fmt.Errorf("HTTP %d", resp.StatusCode())
+	}
+	fi, err := os.Stat(dst)
+	if err != nil {
+		return err
+	}
+	if fi.Size() < otaMinSize {
+		return fmt.Errorf("downloaded file too small: %d bytes", fi.Size())
+	}
+	if expectSize > 0 && fi.Size() != expectSize {
+		return fmt.Errorf("downloaded size mismatch: got %d, want %d", fi.Size(), expectSize)
+	}
+	return nil
+}
+
+// replaceBinary 用新二进制替换当前可执行文件：
+// 1) 当前二进制改名为 .old（Windows 下运行中的 exe 不能删除，但可以重命名）
+// 2) 新文件 rename 到原位置；失败则回滚
+func replaceBinary(tmpPath, exePath string) error {
+	oldPath := exePath + ".old"
+	_ = os.Remove(oldPath)
+
+	if err := os.Rename(exePath, oldPath); err != nil {
+		return fmt.Errorf("backup current binary: %w", err)
+	}
+	if err := os.Rename(tmpPath, exePath); err != nil {
+		_ = os.Rename(oldPath, exePath) // 回滚
+		return fmt.Errorf("install new binary: %w", err)
+	}
+	if runtime.GOOS != "windows" {
+		if err := os.Chmod(exePath, 0o755); err != nil {
+			slog.Warn("OTA chmod failed", "error", err)
+		}
+	}
+	return nil
+}
+
+// restartSelf 用新二进制重启进程：
+//   - Unix：syscall.Exec 原地替换进程镜像（PID 不变，systemd/Docker 无感；Go 的 socket 带
+//     CLOEXEC，exec 瞬间旧监听关闭、新进程正常重绑）
+//   - Windows：运行中的 exe 只能重命名不能替换，采用优雅交接：
+//     1) 优雅停机：停止接收新请求并等待在途请求完成，端口释放
+//     2) 拉起新进程：端口已空闲，子进程可正常绑定（旧实现先 os.Exit 再赌子进程抢端口，
+//     输了就"Server failed to start"退出且 Windows 无守护接管，节点直接下线）
+//     3) 轮询子进程健康检查通过后老进程才退出；超时则以退出码 1 结束
+func restartSelf(exePath string) {
+	if runtime.GOOS == "windows" {
+		gracefulShutdown()
+
+		cmd := exec.Command(exePath, os.Args[1:]...)
+		cmd.Stdout = os.Stdout
+		cmd.Stderr = os.Stderr
+		cmd.Env = os.Environ()
+		if err := cmd.Start(); err != nil {
+			slog.Error("OTA restart failed, waiting for supervisor", "error", err)
+			os.Exit(1)
+		}
+
+		if waitChildReady(cmd, 10*time.Minute) {
+			slog.Info("OTA new process ready, old process exiting", "new_pid", cmd.Process.Pid)
+			os.Exit(0)
+		}
+		slog.Error("OTA new process not ready (exited or timed out), rolling back", "new_pid", cmd.Process.Pid)
+
+		// 回滚：新版本起不来，用 .old 备份恢复服务，而不是陪它一起下线
+		if rollbackToOld(exePath) {
+			slog.Warn("OTA rolled back to previous version, old process exiting")
+			os.Exit(0)
+		}
+		os.Exit(1)
+	}
+
+	if err := syscall.Exec(exePath, os.Args, os.Environ()); err != nil {
+		slog.Error("OTA exec failed, wait for supervisor to restart", "error", err)
+		os.Exit(1)
+	}
+}
+
+// preflightBinary 试运行新二进制（-v 自检：打印版本后立即退出，不读配置不占端口），
+// 确认文件可执行、架构匹配。10s 超时防损坏文件卡死。
+func preflightBinary(path string) error {
+	ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
+	defer cancel()
+	// Stdout/Stderr 为 nil 时输出直接丢弃
+	return exec.CommandContext(ctx, path, "-v").Run()
+}
+
+// waitChildReady 轮询新进程的健康检查接口（GET /），确认其完成端口绑定并对外服务。
+// 返回 true = 就绪；false = 子进程启动期间退出（立即判定失败）或超时未就绪。
+// 超时给足 10 分钟：子进程在数据库文件缺失时（首次启动/文件损坏）会同步拉取约 450MB
+// 库文件后才监听端口，属正常慢启动而非故障——所以判定失败的依据是"子进程退出"
+// （进程死了立即返回），而不是固定超时。
+func waitChildReady(cmd *exec.Cmd, timeout time.Duration) bool {
+	client := &http.Client{Timeout: 2 * time.Second}
+	url := "http://127.0.0.1:" + PORTS + "/"
+	deadline := time.Now().Add(timeout)
+
+	// 监听子进程退出：起不来直接失败，不用干等超时
+	exited := make(chan struct{})
+	go func() {
+		_ = cmd.Wait()
+		close(exited)
+	}()
+
+	for {
+		if resp, err := client.Get(url); err == nil {
+			resp.Body.Close()
+			return true
+		}
+		select {
+		case <-exited:
+			return false
+		case <-time.After(300 * time.Millisecond):
+		}
+		if time.Now().After(deadline) {
+			return false
+		}
+	}
+}
+
+// rollbackToOld 用 .old 备份恢复服务：新版本起不来时，把旧二进制换回原位并重新拉起。
+// 返回 true 表示旧版本已就绪。恢复失败时尽力把新二进制挪回原位后返回 false。
+func rollbackToOld(exePath string) bool {
+	oldPath := exePath + ".old"
+	if _, err := os.Stat(oldPath); err != nil {
+		slog.Error("OTA rollback skipped: no .old backup", "error", err)
+		return false
+	}
+	failed := exePath + ".failed"
+	_ = os.Remove(failed)
+	if err := os.Rename(exePath, failed); err != nil {
+		slog.Error("OTA rollback: cannot move failed binary", "error", err)
+		return false
+	}
+	if err := os.Rename(oldPath, exePath); err != nil {
+		slog.Error("OTA rollback: cannot restore old binary", "error", err)
+		_ = os.Rename(failed, exePath) // 尽力恢复现场
+		return false
+	}
+	cmd := exec.Command(exePath, os.Args[1:]...)
+	cmd.Stdout = os.Stdout
+	cmd.Stderr = os.Stderr
+	cmd.Env = os.Environ()
+	if err := cmd.Start(); err != nil {
+		slog.Error("OTA rollback: cannot start old binary", "error", err)
+		return false
+	}
+	if waitChildReady(cmd, 10*time.Minute) {
+		slog.Warn("OTA rollback serving traffic on previous version", "pid", cmd.Process.Pid)
+		return true
+	}
+	slog.Error("OTA rollback: old binary also failed to become ready")
+	return false
+}

src/report.go

@@ -0,0 +1,324 @@
+package main
+
+import (
+	"bytes"
+	"encoding/json"
+	"fmt"
+	"log/slog"
+	"net/http"
+	"os"
+	"strings"
+	"sync"
+	"time"
+
+	"github.com/coder/websocket"
+	"github.com/gin-gonic/gin"
+)
+
+// ==================== 数据上报（节点 → 收集中心 ipw-boce） ====================
+//
+// 节点是唯一记录者：统计与拨测明细都由本节点上报，中间件不在转发路径上计数，不存在双算。
+// 上报通道（报文同构，协议定义见 ipw-boce 的 report.go）：
+//   - WS 客户端启用（WS_URL 配置且至少一条连接在线）→ 经 WS 发 {"type":"report","data":...}
+//   - WS 未启用或全部连接掉线 → HTTP POST 到收集中心 /report（REPORT_URL）
+//
+// 两条来源都要上报：
+//   - HTTP 接口收到的请求（/v1/*）→ nodeReportMiddleware 计数
+//   - 中间件经 WS 下发的拨测（probe）→ nodeRecordWSProbe 计数
+
+const (
+	reportMaxProbes = 500
+	reportMaxStats  = 500
+)
+
+var (
+	nodeStatsMu    sync.Mutex
+	nodeStats      = map[string]*nodeStatVal{} // apiType → 计数
+	nodeProbeCh    chan nodeProbeRec
+	nodeProbeDropN int64
+	nodeDropMu     sync.Mutex
+)
+
+type nodeStatVal struct {
+	total, errs, latSum, latMax int64
+}
+
+// nodeProbeRec 一条拨测明细（结构与 ipw-boce reportProbe 对齐）
+type nodeProbeRec struct {
+	RequestID string `json:"requestId,omitempty"`
+	NodeID    string `json:"nodeId"`
+	APIType   string `json:"apiType"`
+	Raw       string `json:"raw"`
+	Query     string `json:"query,omitempty"`
+	Status    int    `json:"status"`
+	LatencyMs int64  `json:"latencyMs"`
+	Error     string `json:"error,omitempty"`
+	Source    string `json:"source,omitempty"`
+	Body      string `json:"body,omitempty"`
+	CreatedAt int64  `json:"createdAt,omitempty"`
+}
+
+// nodeIsProbeType 拨测类接口（结果需明细上报）。
+// 明细覆盖：连通性/证书类 detail、ssl，DNS 查询类 dns，直连类 tcping/speed。
+// dnssec 属功能性校验（结果是否签名/可信），不逐条进明细，只进统计聚合。
+func nodeIsProbeType(apiType string) bool {
+	switch apiType {
+	case "tcping", "speed", "detail", "ssl", "dns":
+		return true
+	}
+	return false
+}
+
+// startNodeReporter 启动上报循环（WS 启用或配置 REPORT_URL 时；main() 调用）
+func startNodeReporter() {
+	wsOn := WS_URL != ""
+	if !wsOn && REPORT_URL == "" {
+		return
+	}
+	if REPORT_INTERVAL <= 0 {
+		REPORT_INTERVAL = 15
+	}
+	nodeProbeCh = make(chan nodeProbeRec, 2048)
+	go nodeReportLoop()
+	slog.Info("node reporter enabled", "ws", wsOn, "httpFallback", REPORT_URL, "interval", REPORT_INTERVAL)
+}
+
+// nodeReportMiddleware /v1 组统计中间件：归属规则过滤 → 计数 → 拨测类补明细
+func nodeReportMiddleware() gin.HandlerFunc {
+	return func(c *gin.Context) {
+		start := time.Now()
+		c.Next()
+
+		// 收集中心(ipw-boce)主动调度下发的拨测带 X-Scheduler-Probe 头：
+		// 该次执行由收集中心侧本地落库(source=sched/biz)，本节点跳过计数与明细上报，避免双算。
+		// 真实业务请求（用户/中间件转发）不带此头，仍按"节点是唯一记录者"正常上报。
+		if c.Request.Header.Get("X-Scheduler-Probe") != "" {
+			return
+		}
+
+		apiType, raw := nodeAPIFromPath(c)
+		if apiType == "" {
+			return
+		}
+		latency := time.Since(start)
+		status := c.Writer.Status()
+		nodeRecordAPI(apiType, status, latency)
+		if nodeIsProbeType(apiType) {
+			nodeRecordProbe(nodeProbeRec{
+				NodeID: nodeReportNodeID(), APIType: apiType, Raw: raw,
+				Query: c.Request.URL.RawQuery, Status: status, LatencyMs: latency.Milliseconds(),
+				Source: "http", CreatedAt: time.Now().Unix(),
+			})
+		}
+	}
+}
+
+// nodeRecordWSProbe WS 拨测出口（ws.go wsHandleProbe 调用）。
+// 中间件已不在转发路径上计数，WS 下发的拨测同样由本节点上报（唯一记录者）；
+// requestId 只作为明细的关联标识带出，不参与归属判断。
+func nodeRecordWSProbe(requestID, apiType, raw string, query map[string]string, status int, latency time.Duration) {
+	if apiType == "" {
+		return
+	}
+	nodeRecordAPI(apiType, status, latency)
+	if nodeIsProbeType(apiType) {
+		q := ""
+		for k, v := range query {
+			if q != "" {
+				q += "&"
+			}
+			q += k + "=" + v
+		}
+		nodeRecordProbe(nodeProbeRec{
+			RequestID: requestID,
+			NodeID:    nodeReportNodeID(), APIType: apiType, Raw: raw, Query: q,
+			Status: status, LatencyMs: latency.Milliseconds(), Source: "ws",
+			CreatedAt: time.Now().Unix(),
+		})
+	}
+}
+
+func nodeRecordAPI(apiType string, status int, latency time.Duration) {
+	ms := latency.Milliseconds()
+	nodeStatsMu.Lock()
+	v, ok := nodeStats[apiType]
+	if !ok {
+		v = &nodeStatVal{}
+		nodeStats[apiType] = v
+	}
+	v.total++
+	if status == 0 || status >= 500 {
+		v.errs++
+	}
+	v.latSum += ms
+	if ms > v.latMax {
+		v.latMax = ms
+	}
+	nodeStatsMu.Unlock()
+}
+
+func nodeRecordProbe(rec nodeProbeRec) {
+	if nodeProbeCh == nil {
+		return
+	}
+	select {
+	case nodeProbeCh <- rec:
+	default:
+		nodeDropMu.Lock()
+		nodeProbeDropN++
+		n := nodeProbeDropN
+		nodeDropMu.Unlock()
+		if n%100 == 1 {
+			slog.Warn("node report probe queue full", "dropped", n)
+		}
+	}
+}
+
+// nodeReportNodeID 上报身份：优先 node-id（WS_NODE_ID），否则 hostname
+func nodeReportNodeID() string {
+	if WS_NODE_ID != "" {
+		return WS_NODE_ID
+	}
+	if h, err := os.Hostname(); err == nil && h != "" {
+		return h
+	}
+	return "unknown"
+}
+
+// nodeAPIFromPath 从 gin 路由模板提取 apiType 与拨测目标（对齐 WS probe 的 raw 格式）
+func nodeAPIFromPath(c *gin.Context) (apiType, raw string) {
+	path := c.FullPath() // 形如 /v1/tcping/:ip
+	if !strings.HasPrefix(path, "/v1/") {
+		return "", ""
+	}
+	seg := strings.SplitN(strings.TrimPrefix(path, "/v1/"), "/", 2)
+	if len(seg) == 0 || seg[0] == "" {
+		return "", ""
+	}
+	apiType = seg[0]
+	switch apiType {
+	case "tcping", "dnssec", "whois":
+		raw = c.Param("ip")
+		if raw == "" {
+			raw = c.Param("domain")
+		}
+	case "speed":
+		raw = c.Param("version") + c.Param("url") // v4/example.com（对齐 WS probe raw 格式）
+	case "dns":
+		raw = c.Param("type") + c.Param("domain") // a/example.com
+	case "detail", "ssl":
+		raw = strings.TrimPrefix(c.Param("url"), "/")
+	case "location", "asn":
+		raw = c.Param("ip")
+	}
+	return apiType, raw
+}
+
+// nodeReportLoop 周期上报：WS 在线走 WS 广播（所有已注册中间件），否则 HTTP POST 收集中心
+func nodeReportLoop() {
+	ticker := time.NewTicker(time.Duration(REPORT_INTERVAL) * time.Second)
+	defer ticker.Stop()
+	for range ticker.C {
+		payload := nodeBuildPayload()
+		if payload == nil {
+			continue
+		}
+		sent := wsBroadcastReport(payload)
+		if !sent && REPORT_URL != "" {
+			if err := nodeHTTPReport(payload); err != nil {
+				slog.Warn("node http report failed", "error", err)
+			}
+		}
+	}
+}
+
+// nodeBuildPayload 取走当前计数与拨测缓冲，组装上报报文；无数据返回 nil。
+// minute 传 0 = 收集器按自己时钟入桶（节点时钟不可信时不影响聚合口径）
+func nodeBuildPayload() map[string]any {
+	nodeStatsMu.Lock()
+	snap := nodeStats
+	nodeStats = make(map[string]*nodeStatVal, len(snap))
+	nodeStatsMu.Unlock()
+
+	probes := make([]nodeProbeRec, 0, reportMaxProbes)
+	if nodeProbeCh != nil {
+	drain:
+		for len(probes) < reportMaxProbes {
+			select {
+			case r := <-nodeProbeCh:
+				probes = append(probes, r)
+			default:
+				break drain // 队列已空，本轮结束
+			}
+		}
+	}
+	if len(snap) == 0 && len(probes) == 0 {
+		return nil
+	}
+	minute := time.Now().UTC().Unix() / 60
+	stats := make([]map[string]any, 0, len(snap))
+	for apiType, v := range snap {
+		stats = append(stats, map[string]any{
+			"minute": minute, "nodeId": nodeReportNodeID(), "apiType": apiType,
+			"total": v.total, "errors": v.errs, "latencySumMs": v.latSum, "latencyMaxMs": v.latMax,
+		})
+	}
+	payload := map[string]any{
+		"instance": nodeReportNodeID(),
+		"stats":    stats,
+	}
+	if len(probes) > 0 {
+		payload["probes"] = probes
+	}
+	return payload
+}
+
+// wsBroadcastReport 经 WS 通道向所有在线中间件广播 report 消息；无在线连接返回 false（触发 HTTP 兜底）
+func wsBroadcastReport(payload map[string]any) bool {
+	sent := false
+	data, _ := json.Marshal(payload)
+	wsActiveConns.Range(func(_, v any) bool {
+		if c, ok := v.(*websocket.Conn); ok && c != nil {
+			if err := wsSendErr(c, wsMsg{Type: "report", NodeID: WS_NODE_ID, Data: data}); err != nil {
+				slog.Warn("node ws report send failed", "error", err)
+			} else {
+				sent = true
+			}
+		}
+		return true
+	})
+	return sent
+}
+
+// nodeHTTPReport HTTP 兜底上报（WS 未启用/全部掉线时）
+func nodeHTTPReport(payload map[string]any) error {
+	body, err := json.Marshal(payload)
+	if err != nil {
+		return err
+	}
+	url := strings.TrimSuffix(REPORT_URL, "/") + "/report"
+	req, err := http.NewRequest(http.MethodPost, url, bytes.NewReader(body))
+	if err != nil {
+		return err
+	}
+	req.Header.Set("Content-Type", "application/json")
+	if REPORT_TOKEN != "" {
+		req.Header.Set("Authorization", "Bearer "+REPORT_TOKEN)
+	}
+	client := &http.Client{Timeout: 10 * time.Second}
+	resp, err := client.Do(req)
+	if err != nil {
+		return err
+	}
+	defer resp.Body.Close()
+	if resp.StatusCode < 200 || resp.StatusCode >= 300 {
+		return &httpStatusError{status: resp.StatusCode}
+	}
+	return nil
+}
+
+type httpStatusError struct{ status int }
+
+func (e *httpStatusError) Error() string {
+	return fmt.Sprintf("collector returned status %d", e.status)
+}

src/setting.json.example

@@ -0,0 +1,21 @@
+{
+    "port": 8080,
+    "gh-proxy": "",
+    "single-stack": "",
+    "dns-server": "",
+    "dnssec-server": "",
+    "block-private-ips": true,
+    "ipdb": "false",
+    "cors": "",
+    "trusted-proxies": "",
+    "remote-config-url": "",
+    "remote-ignore-config": [],
+    "access-token": "",
+    "ws-url": "",
+    "node-id": "",
+    "node-key": "",
+    "node-ota": "false",
+    "report-url": "",
+    "report-token": "",
+    "report-interval-seconds": 15
+}

src/ssrf/ssrf.go

@@ -45,24 +45,49 @@ func SetEnabled(v bool) {
 	blockPrivateIPs = v
 }
 
+// Go 标准库 IsPrivate 只覆盖 RFC1918 与 fd00::/8，这里补齐其余不应出网的内部/特殊网段
+var extraPrivateNets = mustParseCIDRs(
+	"100.64.0.0/10", // CGNAT：运营商级 NAT、云内网、Tailscale 等
+	"198.18.0.0/15", // 网络基准测试保留段
+	"192.0.0.0/24",  // IETF 协议分配
+	"fc00::/7",      // IPv6 ULA（IsPrivate 只认 fd00::/8）
+	"64:ff9b::/96",  // NAT64：内嵌 IPv4 会被网关转换
+)
+
+func mustParseCIDRs(cidrs ...string) []*net.IPNet {
+	nets := make([]*net.IPNet, 0, len(cidrs))
+	for _, c := range cidrs {
+		_, ipNet, err := net.ParseCIDR(c)
+		if err != nil {
+			panic(fmt.Sprintf("invalid CIDR %q: %v", c, err))
+		}
+		nets = append(nets, ipNet)
+	}
+	return nets
+}
+
 // IsPrivateIP checks if the given IP address belongs to a private or internal range.
 // IsPrivateIP 检查给定的 IP 地址是否属于私有或内部地址段。
-// It covers RFC 1918 private addresses, loopback, link-local, and unspecified addresses.
-// 涵盖 RFC 1918 私有地址、回环地址、链路本地地址和未指定地址。
+// It covers RFC 1918 private addresses, loopback, link-local, and unspecified addresses,
+// plus CGNAT/ULA/NAT64/benchmark/multicast ranges that Go's IsPrivate does not cover.
+// 涵盖 RFC 1918 私有地址、回环地址、链路本地地址和未指定地址，
+// 以及 Go 标准库未覆盖的 CGNAT/ULA/NAT64/基准测试/组播段。
 // This is the core check used to block SSRF attacks targeting internal networks.
 // 这是用于阻止针对内部网络的 SSRF 攻击的核心检查。
 func IsPrivateIP(ip net.IP) bool {
-	if ip.IsPrivate() {
+	if ip == nil {
+		return false
+	}
+	if ip.IsPrivate() || ip.IsLoopback() || ip.IsLinkLocalUnicast() || ip.IsUnspecified() || ip.IsMulticast() {
 		return true
 	}
-	if ip.IsLoopback() {
+	if ip.Equal(net.IPv4bcast) {
 		return true
 	}
-	if ip.IsLinkLocalUnicast() {
-		return true
-	}
-	if ip.IsUnspecified() {
-		return true
+	for _, n := range extraPrivateNets {
+		if n.Contains(ip) {
+			return true
+		}
 	}
 	return false
 }
@@ -133,36 +158,35 @@ func ValidateOutboundTarget(ctx context.Context, targetURL string) (context.Cont
 // SecureCheckRedirect is a redirect policy that prevents SSRF via HTTP redirect chains.
 // SecureCheckRedirect 是一个重定向策略，防止通过 HTTP 重定向链进行 SSRF 攻击。
 //
-// When an HTTP client follows redirects (301, 302, 307, 308), each intermediate target
-// 当 HTTP 客户端跟随重定向（301、302、307、308）时，会校验每个中间目标
-// is resolved and checked against private/internal IP ranges.
-// 的解析结果，并检查是否指向私有/内部 IP 段。
-//
-// This blocks attackers from:
-// 这阻止攻击者通过以下方式绕过防护：
-//   - Using an initial public redirect that points to an internal service.
-//     使用指向内部服务的初始公开重定向。
-//   - Chaining multiple redirects to eventually reach a private IP.
-//     链式多个重定向最终到达私有 IP。
+// req 是即将跳转的目标（via 是已访问的链）。必须校验目标本身：
+// 只检查 via 会漏掉重定向链的最后一跳。每一跳的目标都会被解析并检查
+// 是否指向私有/内部 IP 段，同时限制重定向深度。
+// 这阻止攻击者通过链式重定向最终到达私有 IP。
 func SecureCheckRedirect(req *http.Request, via []*http.Request) error {
 	if !blockPrivateIPs {
 		return nil
 	}
-	for _, r := range via {
-		redirectURL := r.URL
-		host := redirectURL.Hostname()
-		if host == "" {
-			continue
-		}
-		ips, err := net.LookupIP(host)
-		if err != nil {
-			return err
-		}
-		for _, ip := range ips {
-			if IsPrivateIP(ip) {
-				slog.Warn("Blocked redirect to private IP", "host", host, "ip", ip)
-				return fmt.Errorf("redirect to private/internal address is not allowed")
-			}
+	if req == nil || req.URL == nil {
+		return fmt.Errorf("invalid redirect target")
+	}
+	if req.URL.Scheme != "http" && req.URL.Scheme != "https" {
+		return fmt.Errorf("invalid redirect scheme: %s", req.URL.Scheme)
+	}
+	host := req.URL.Hostname()
+	if host == "" {
+		return fmt.Errorf("redirect target has empty host")
+	}
+	if len(via) >= 10 {
+		return fmt.Errorf("stopped after 10 redirects")
+	}
+	ips, err := net.LookupIP(host)
+	if err != nil {
+		return err
+	}
+	for _, ip := range ips {
+		if IsPrivateIP(ip) {
+			slog.Warn("Blocked redirect to private IP", "host", host, "ip", ip)
+			return fmt.Errorf("redirect to private/internal address is not allowed")
 		}
 	}
 	return nil

src/webtest/helpers.go

@@ -1,6 +1,7 @@
 package webtest
 
 import (
+	"net/netip"
 	"net/url"
 	"strings"
 	"time"
@@ -42,3 +43,13 @@ func measureDNSTime(urlStr string, version string) float64 {
 	}
 	return time.Since(start).Seconds() * 1000
 }
+func AddrPortsToCSV(addrs []netip.AddrPort) string {
+	if len(addrs) == 0 {
+		return ""
+	}
+	parts := make([]string, len(addrs))
+	for i, addr := range addrs {
+		parts[i] = addr.String() // 自动格式化为 "IP:Port"
+	}
+	return strings.Join(parts, ",")
+}

src/webtest/whois.go

@@ -1,6 +1,7 @@
 package webtest
 
 import (
+	"bytes"
 	"context"
 	"fmt"
 	"net"
@@ -200,7 +201,6 @@ func happyEyeballsWhoisQuery(domain string, v4IPs, v6IPs []string, port string)
 	}
 	// 有缓冲：保证每个 goroutine 写入不被阻塞，避免 goroutine 泄漏
 	ch := make(chan outcome, len(v4IPs)+len(v6IPs))
-	pending := 0
 
 	tryIP := func(ip string) {
 		raw, err := rawWhoisQueryCtx(ctx, domain, ip, port)
@@ -209,7 +209,6 @@ func happyEyeballsWhoisQuery(domain string, v4IPs, v6IPs []string, port string)
 
 	// 1) 立即启动所有 v4
 	for _, ip := range v4IPs {
-		pending++
 		go tryIP(ip)
 	}
 
@@ -218,7 +217,6 @@ func happyEyeballsWhoisQuery(domain string, v4IPs, v6IPs []string, port string)
 	if len(v6IPs) > 0 {
 		v6Timer = time.AfterFunc(happyEyeballsV6Delay, func() {
 			for _, ip := range v6IPs {
-				pending++
 				go tryIP(ip)
 			}
 		})
@@ -241,9 +239,7 @@ func happyEyeballsWhoisQuery(domain string, v4IPs, v6IPs []string, port string)
 		case <-ctx.Done():
 			return "", ctx.Err()
 		}
-		// 注意：pending 是在 goroutine 内自增，这里用固定上限做兜底计数
-		// 如果 v6 还没启动完，但 v4 已经全部失败也没有成功，需要等待 pending 全部发完
-		// 简化起见：若 i 到达 len(v4IPs) 但 v6 还在 pending，我们再等一会
+		// v4 全部失败且无成功时，给延迟启动的 v6 goroutine 留一个启动 + 写入窗口
 		if i == len(v4IPs)-1 && v6Timer != nil && lastErr != nil {
 			// 给 v6 一个启动 + 写入窗口
 			time.Sleep(happyEyeballsV6Delay + 20*time.Millisecond)
@@ -336,19 +332,29 @@ func rawWhoisQueryCtx(ctx context.Context, domain, server, port string) (string,
 		}
 	}
 
-	// 3. 读取响应
+	// 3. 读取响应：循环读到 EOF/超时。单次 Read 只能拿到一个 TCP 段，会截断大多数 WHOIS 响应
 	buf := make([]byte, 65536)
-	n, readErr := conn.Read(buf)
-
-	// 有数据就读到了，哪怕 readErr != nil 也先返回数据
-	if n > 0 {
-		return string(buf[:n]), nil
-	}
-	select {
-	case <-ctx.Done():
-		return "", ctx.Err()
-	default:
-		return "", readErr
+	var out bytes.Buffer
+	for {
+		n, readErr := conn.Read(buf)
+		if n > 0 {
+			out.Write(buf[:n])
+		}
+		if readErr != nil {
+			// 有数据就返回（EOF/超时都视为读完），哪怕 readErr != nil
+			if out.Len() > 0 {
+				return out.String(), nil
+			}
+			select {
+			case <-ctx.Done():
+				return "", ctx.Err()
+			default:
+				return "", readErr
+			}
+		}
+		if out.Len() > 1<<20 { // 防御上限 1MB，避免异常响应无限读
+			return out.String(), nil
+		}
 	}
 }
 

src/ws.go

@@ -5,6 +5,7 @@ import (
 	"encoding/json"
 	"fmt"
 	"log/slog"
+	"strconv"
 	"strings"
 	"sync"
 	"time"
@@ -18,15 +19,15 @@ import (
 //
 // 配置（readConfig 解析，环境变量优先，其次 setting.json，远端配置可覆盖）：
 //
-//	WS_URL    ws://<中间件>:8092/ws,ws://<备中间件>:8092/ws   （逗号分隔多个中间件，主失败自动切换下一个；不配置 = 不启用）
-//	NODE_ID   节点 id（与中间件 apiKeys 键 / 前端配置 id 一致）
-//	NODE_KEY  注册 key（与中间件 apiKeys[节点id] 一致；中间件未配置该节点 key 时留空）
+//	WS_URL    ws://<中间件>:8092/ws,ws://<备中间件>:8092/ws   （逗号分隔多个中间件，同时连接全部，多活；不配置 = 不启用）
+//	NODE_ID   节点 id（与中间件 ws-keys 键 / 前端配置 id 一致）
+//	NODE_KEY  注册 key（与中间件 ws-keys[节点id] 一致；中间件未配置该节点 key 时留空）
 //
 // 与 HTTP handler 共用同一批 webtest 探针函数和缓存：收到 probe 后按 apiType 取数（带缓存），
 // 返回处理在本文件内完成，结果经 probe_result 上报。节点 HTTP 接口完全不变。
 //
 // 心跳：NODE 与 MIDDLEWARE 双向心跳。本端每 10s 发一次 ping，发送失败重试，连续失败 3 次
-// 判定当前中间件不可用，断开并切换下一个 WS_URL；收到中间件 ping 回 pong。
+// 判定当前中间件不可用，断开该连接并按同一 URL 独立重连（不影响其他中间件连接）。
 
 // wsProbe 学 HTTP handler：从函数拿数据 + 缓存，返回 (status, body)。
 // raw 与 query 来自中间件 probe 消息（等价于路由参数）。
@@ -106,6 +107,12 @@ func wsProbe(apiType, raw string, query map[string]string) (int, any) {
 		if port == "" {
 			port = "80"
 		}
+		// 与 HTTP handler 同样校验端口/次数，避免垃圾参数直接进拨号
+		p, err := strconv.Atoi(port)
+		if err != nil || p < 1 || p > 65535 {
+			return 400, map[string]string{"error": "Invalid port number"}
+		}
+		port = strconv.Itoa(p)
 		count := query["count"]
 		n := 4
 		if count != "" {
@@ -126,7 +133,9 @@ func wsProbe(apiType, raw string, query map[string]string) (int, any) {
 				return webtest.TCPingRun(host, port, n, v, 10*time.Second, 100*time.Millisecond)
 			},
 			func(err error) *webtest.TCPingStats { return &webtest.TCPingStats{IP: "Error: " + err.Error()} },
-			func(v string) *webtest.TCPingStats { return &webtest.TCPingStats{IP: "Skipped due to SINGLE_STACK=" + v} },
+			func(v string) *webtest.TCPingStats {
+				return &webtest.TCPingStats{IP: "Skipped due to SINGLE_STACK=" + v}
+			},
 		)
 		result := &TCPingResult{IPv4: ipv4, IPv6: ipv6}
 		pingCache.Store(cacheKey, pingCacheEntry{result: result, timestamp: time.Now()})
@@ -200,8 +209,13 @@ func wsProbe(apiType, raw string, query map[string]string) (int, any) {
 		if raw == "" {
 			return 400, map[string]string{"error": "IP parameter is required"}
 		}
-		result := ipdb.SearchIP(raw, "maxmind_asn", "dbip_asn")
+		result := ipdb.SearchIP(raw, "maxmind_asn", "dbip_asn", "ip2location_asn")
 		asnResult := map[string]any{"ip": raw}
+		if ip2locASN, ok := result["ip2location_asn"].(map[string]string); ok && ip2locASN["asn"] != "" {
+			asnResult["ip2location_asn"] = map[string]string{"asn": ip2locASN["asn"], "as": ip2locASN["as"]}
+		} else if errStr, ok := result["ip2location_asn"].(string); ok {
+			asnResult["ip2location_asn"] = map[string]string{"error": errStr}
+		}
 		if maxmindASN, ok := result["maxmind_asn"].(*ipdb.MMDBASNResult); ok {
 			asnResult["geolite2_asn"] = map[string]string{"asn": maxmindASN.ASN, "org": maxmindASN.Org}
 		} else if errStr, ok := result["maxmind_asn"].(string); ok {
@@ -322,19 +336,30 @@ func wsRaw(v any) json.RawMessage {
 	return b
 }
 
-// wsHandleProbe 处理中间件下发的拨测请求（并发执行）：取数 → probe_result
+// wsActiveConns 当前已注册的中间件连接（url → conn）：注册成功写入、断开移除，数据上报广播用（report.go）
+var wsActiveConns sync.Map
+
+// wsHandleProbe 处理中间件/收集中心经 WS 下发的拨测请求（并发执行）：取数 → probe_result。
+// 归属规则：报文带 Scheduler=true = 收集中心主动调度拨测（收集中心侧已本地落库 sched/biz），
+// 本节点跳过 data 上报，避免双算；仅回 probe_result。不带 Scheduler 的 WS probe
+// （如中间件转发真实业务）仍由本节点上报（节点是唯一记录者，见 report.go）。
 func wsHandleProbe(c *websocket.Conn, data json.RawMessage) {
 	var req struct {
 		RequestID string            `json:"requestId"`
 		APIType   string            `json:"apiType"`
 		Raw       string            `json:"raw"`
 		Query     map[string]string `json:"query"`
+		Scheduler bool              `json:"scheduler"`
 	}
 	if err := json.Unmarshal(data, &req); err != nil || req.RequestID == "" || req.APIType == "" {
 		slog.Warn("ws client bad probe message")
 		return
 	}
+	start := time.Now()
 	status, body := wsProbe(req.APIType, req.Raw, req.Query)
+	if !req.Scheduler {
+		nodeRecordWSProbe(req.RequestID, req.APIType, req.Raw, req.Query, status, time.Since(start))
+	}
 	payload := struct {
 		RequestID string          `json:"requestId"`
 		Status    int             `json:"status"`
@@ -360,8 +385,8 @@ const (
 	wsHeartbeatTimeout  = 5 * time.Second
 )
 
-// wsClientOnce 连接并服务单个中间件 URL，返回下次重试前的等待时长：
-//   - 连接/读循环断开 → 3s（切换下一个中间件）
+// wsClientOnce 连接并服务单个中间件 URL，返回下次重试前的等待时长（由 per-URL 连接循环调用）：
+//   - 连接/读循环断开 → 3s（重试同一 URL）
 //   - 注册被拒（register_error）→ 30s（多为 key 配置错误，加大间隔避免空转刷日志）
 //   - 心跳连续失败 wsHeartbeatRetry 次 → 主动断开，3s
 //   - 返回 0 = 配置缺失（不再重试）
@@ -372,7 +397,10 @@ func wsClientOnce(url string) time.Duration {
 		slog.Warn("ws client dial failed", "url", url, "error", err)
 		return 3 * time.Second
 	}
-	defer c.CloseNow()
+	defer func() {
+		wsActiveConns.Delete(url)
+		c.CloseNow()
+	}()
 
 	reg := map[string]string{"nodeId": WS_NODE_ID}
 	if WS_NODE_KEY != "" {
@@ -380,7 +408,10 @@ func wsClientOnce(url string) time.Duration {
 	}
 	wsSend(c, wsMsg{Type: "register", Data: wsRaw(reg)})
 
-	_, data, err := c.Read(ctx)
+	// 注册应答限时读取：中间件半死（TCP 通但不回包）时 goroutine 会永久阻塞在 Read 上
+	regCtx, regCancel := context.WithTimeout(ctx, 15*time.Second)
+	defer regCancel()
+	_, data, err := c.Read(regCtx)
 	if err != nil {
 		slog.Warn("ws client register read failed", "url", url, "error", err)
 		return 3 * time.Second
@@ -398,8 +429,9 @@ func wsClientOnce(url string) time.Duration {
 		return 3 * time.Second
 	}
 	slog.Info("ws client registered", "nodeId", WS_NODE_ID, "url", url)
+	wsActiveConns.Store(url, c)
 
-	// 心跳 goroutine：每 10s 发 ping，失败重试，连续 3 次失败主动断开（上层切换下一个中间件）
+	// 心跳 goroutine：每 10s 发 ping，失败重试，连续 3 次失败主动断开（per-URL 循环重连同一中间件）
 	stopHeartbeat := make(chan struct{})
 	go func() {
 		fail := 0
@@ -413,7 +445,7 @@ func wsClientOnce(url string) time.Duration {
 				fail++
 				slog.Warn("ws heartbeat send failed", "url", url, "fail", fail, "error", err)
 				if fail >= wsHeartbeatRetry {
-					slog.Warn("ws heartbeat failed too many times, switching middleware", "url", url)
+					slog.Warn("ws heartbeat failed too many times, closing connection (will retry same url)", "url", url)
 					c.Close(websocket.StatusPolicyViolation, "heartbeat timeout")
 					return
 				}
@@ -445,23 +477,35 @@ func wsClientOnce(url string) time.Duration {
 	}
 }
 
-// wsClientLoop 主循环：依次尝试所有配置的中间件 URL（逗号分隔，第一个为主），
-// 当前中间件连接失败或心跳超时 → 3s 后切换下一个；注册被拒 → 30s；全部失败循环重试。
+// wsClientLoop 同时连接所有配置的中间件 URL（逗号分隔，多活）：
+// 每个 URL 由独立 goroutine 负责，各自注册并保持连接，任一断开只重连自己，不影响其他中间件。
+// 注意：多个 URL 指向同一中间件实例时，中间件按 nodeId 单连接，后注册的连接会顶掉先前的。
 func wsClientLoop() {
 	urls := splitWSURLs(WS_URL)
 	if len(urls) == 0 {
 		slog.Info("ws client disabled (WS_URL not set)")
 		return
 	}
+	var wg sync.WaitGroup
+	for _, url := range urls {
+		wg.Add(1)
+		go func(u string) {
+			defer wg.Done()
+			wsClientOnceLoop(u)
+		}(url)
+	}
+	wg.Wait()
+}
+
+// wsClientOnceLoop 单个中间件 URL 的持续连接循环：连接 → 注册 → 心跳/读循环 → 断开重试
+func wsClientOnceLoop(url string) {
 	for {
-		for _, url := range urls {
-			retryDelay := wsClientOnce(url)
-			if retryDelay == 0 {
-				slog.Info("ws client stopped")
-				return
-			}
-			time.Sleep(retryDelay)
+		retryDelay := wsClientOnce(url)
+		if retryDelay == 0 {
+			slog.Info("ws client stopped", "url", url)
+			return
 		}
+		time.Sleep(retryDelay)
 	}
 }