Bump to Beta 0.4.3

Status, priority/torrent chips and IP columns like the users tab; the API
returns each device's IP per server. The key row sums its devices (online,
priority, traffic); key UUID and device ID sit under the name, copy on click.

.env

@@ -7,8 +7,8 @@
 #
 # ⚠️ VERSION и CHANNEL продублированы в install.sh: установщик печатает баннер и
 # собирает URL релиза ДО того, как архив с этим файлом скачан. При бампе версии
-# правь оба места (и три package.json).
+# правь оба места (и package.json сервисов).
 
 BRAND=Forgetting
 CHANNEL=Beta
-VERSION=0.3.4
+VERSION=0.4.3

.gitea/workflows/ci.yml

@@ -26,6 +26,18 @@ jobs:
       - name: Installer syntax
         run: bash -n install.sh
 
+      # Go-переписывание (awg-control): сборка, vet и тесты. composites выключен —
+      # jsjson.KV{k, v} без имён полей написан так намеренно.
+      - uses: actions/setup-go@v5
+        with:
+          go-version-file: go.mod
+
+      - name: Go build, vet, test
+        run: |
+          go build ./...
+          go vet -composites=false ./...
+          go test -race ./...
+
       - name: awg-ctrl types
         working-directory: awg-ctrl
         run: |

.gitea/workflows/release.yml

@@ -1,5 +1,5 @@
-# Публикация релиза в Gitea. Зеркало .github/workflows/release.yml: собирает тот
-# же архив, но заливает его через API Gitea — gh CLI в раннере нет.
+# Публикация релиза в Gitea. Зеркало .github/workflows/release.yml: собирает те
+# же архивы, но заливает его через API Gitea — gh CLI в раннере нет.
 #
 # Gitea читает workflow из .gitea/workflows; когда этот каталог есть, файлы из
 # .github/workflows она не запускает, так что GitHub-версия остаётся только для
@@ -39,12 +39,13 @@ jobs:
           npm install
           npm run build
 
-      - name: Package archive
-        run: |
-          VERSION="${GITHUB_REF_NAME#v}"
-          mkdir "awgcontrol-${VERSION}"
-          cp -r awg-ctrl awg-ui awg-agent cli .env "awgcontrol-${VERSION}/"
-          tar --exclude='node_modules' -czf "awgcontrol-${VERSION}.tar.gz" "awgcontrol-${VERSION}/"
+      - uses: actions/setup-go@v5
+        with:
+          go-version-file: go.mod
+
+      # Архив на архитектуру: Go-бинарник awg-control + собранный фронтенд + .env.
+      - name: Package archives
+        run: sh tools/release/package.sh "${GITHUB_REF_NAME#v}"
 
       # Токен выбираем в bash, а не выражением ${{ a || b }}: так поведение не
       # зависит от версии движка выражений в Gitea.
@@ -58,7 +59,6 @@ jobs:
           [ -n "$TOKEN" ] || { echo "нет токена: ни RELEASE_TOKEN, ни GITEA_TOKEN"; exit 1; }
 
           VERSION="${GITHUB_REF_NAME#v}"
-          ARCHIVE="awgcontrol-${VERSION}.tar.gz"
           API="${GITHUB_SERVER_URL}/api/v1/repos/${GITHUB_REPOSITORY}"
 
           # id релиза — первое поле в JSON Gitea, поэтому берём ПЕРВОЕ вхождение
@@ -82,8 +82,10 @@ jobs:
           fi
           [ -n "$id" ] || { echo "не удалось получить id релиза"; exit 1; }
 
-          curl -sS --fail -X POST "$API/releases/${id}/assets?name=${ARCHIVE}" \
-            -H "Authorization: token $TOKEN" \
-            -F "attachment=@${ARCHIVE};type=application/gzip" > /dev/null
+          for ARCHIVE in awgcontrol-"${VERSION}"-linux-*.tar.gz; do
+            curl -sS --fail -X POST "$API/releases/${id}/assets?name=${ARCHIVE}" \
+              -H "Authorization: token $TOKEN" \
+              -F "attachment=@${ARCHIVE};type=application/gzip" > /dev/null
+          done
 
           echo "опубликовано: ${GITHUB_SERVER_URL}/${GITHUB_REPOSITORY}/releases/tag/${GITHUB_REF_NAME}"

.github/workflows/ci.yml

@@ -23,6 +23,18 @@ jobs:
       - name: Installer syntax
         run: bash -n install.sh
 
+      # Go-переписывание (awg-control): сборка, vet и тесты. composites выключен —
+      # jsjson.KV{k, v} без имён полей написан так намеренно.
+      - uses: actions/setup-go@v5
+        with:
+          go-version-file: go.mod
+
+      - name: Go build, vet, test
+        run: |
+          go build ./...
+          go vet -composites=false ./...
+          go test -race ./...
+
       - name: awg-ctrl types
         working-directory: awg-ctrl
         run: |

.github/workflows/release.yml

@@ -4,6 +4,12 @@ on:
   push:
     tags:
       - 'v*'
+  # Ручной запуск: тег создаётся при публикации на коммите, с которого запущен workflow.
+  workflow_dispatch:
+    inputs:
+      tag:
+        description: 'Тег релиза, например v0.4.0'
+        required: true
 
 permissions:
   contents: write
@@ -11,6 +17,8 @@ permissions:
 jobs:
   release:
     runs-on: ubuntu-latest
+    env:
+      TAG: ${{ github.event_name == 'workflow_dispatch' && inputs.tag || github.ref_name }}
     steps:
       - uses: actions/checkout@v4
 
@@ -24,17 +32,18 @@ jobs:
           npm install
           npm run build
 
-      - name: Package archive
-        run: |
-          VERSION="${GITHUB_REF_NAME#v}"
-          mkdir "awgcontrol-${VERSION}"
-          cp -r awg-ctrl awg-ui awg-agent cli .env "awgcontrol-${VERSION}/"
-          tar --exclude='node_modules' -czf "awgcontrol-${VERSION}.tar.gz" "awgcontrol-${VERSION}/"
+      - uses: actions/setup-go@v5
+        with:
+          go-version-file: go.mod
+
+      # Архив на архитектуру: Go-бинарник awg-control + собранный фронтенд + .env.
+      - name: Package archives
+        run: sh tools/release/package.sh "${TAG#v}"
 
       - name: Publish release
         env:
           GH_TOKEN: ${{ github.token }}
         run: |
-          VERSION="${GITHUB_REF_NAME#v}"
-          gh release create "${GITHUB_REF_NAME}" "awgcontrol-${VERSION}.tar.gz" \
-            --title "${GITHUB_REF_NAME}" --generate-notes --prerelease
+          VERSION="${TAG#v}"
+          gh release create "${TAG}" awgcontrol-"${VERSION}"-linux-*.tar.gz \
+            --target "${GITHUB_SHA}" --title "${TAG}" --generate-notes --prerelease

.gitignore

@@ -20,4 +20,7 @@ yarn-error.log*
 
 # Все markdown, кроме README.md
 *.md
-!README.md
+!README.md
+# Go: бинарники и прогоны дифференциального стенда
+tools/diffbench/bin/
+tools/diffbench/out/

README.md

@@ -4,13 +4,15 @@
 > Данный проект предназначен только для использования в законных целях.
 ## Архитектура
 
-Три компонента, устанавливаются в `/opt/awg-control/`:
+Один статический бинарник `awg-control` (Go) в `/opt/awg-control/` — в нём все роли;
+команда `awg-ctrl` — ссылка на него:
 
 | Компонент | Роль |
 |---|---|
-| **awg-ctrl** | Привилегированный REST-бэкенд. Управляет пирами через `awg`/`awg-quick`, ведёт SQLite-базу, генерирует `vpn://` ключи. Слушает только loopback. |
-| **awg-ui** | Express + React. Веб-панель, аутентификация (JWT), прокси к awg-ctrl, публичный API `/api/v1` и своя база его ключей. Единственный сервис, доступный по сети. |
-| **cli** | Менеджер процессов: `start`/`stop`/`restart`/`status`, смена логина/пароля панели, интерактивное TUI-меню. |
+| **awg-ctrl** (`awg-control ctrl`) | Привилегированный REST-бэкенд. Управляет пирами через `awg`/`awg-quick`, ведёт SQLite-базу, генерирует `vpn://` ключи. Слушает только loopback. |
+| **awg-ui** (`awg-control ui`) | Веб-панель (фронтенд на React, `awg-ui/dist`), аутентификация (JWT), прокси к awg-ctrl, публичный API `/api/v1` и своя база его ключей. Единственный сервис, доступный по сети. |
+| **awg-agent** (`awg-control agent`) | Только на ноде: исходящее WSS-соединение к панели, исполняет её запросы на локальном awg-ctrl. |
+| **cli** (`awg-ctrl …`) | Менеджер процессов: `start`/`stop`/`restart`/`status`, смена логина/пароля панели, интерактивное TUI-меню. |
 
 Внутренняя связь awg-ui → awg-ctrl подписывается асимметрично (Ed25519): приватный ключ только у awg-ui, awg-ctrl проверяет подпись публичным.
 
@@ -19,7 +21,7 @@
 - **Права**: root.
 - **Ядро**: kvm (не OpenVZ/LXC/Docker/WSL — нужен загружаемый kernel-модуль AmneziaWG).
 - **Заголовки ядра** под текущее ядро (для сборки DKMS-модуля).
-- **Node.js 20.x** (ставится установщиком автоматически).
+- **Архитектура**: x86_64 или aarch64.
 
 Совместимость установщик проверяет сам перед любыми изменениями.
 
@@ -28,7 +30,7 @@
 На сервере, от root:
 
 ```bash
-bash <(curl -Ls https://git.ma7neko.ru/maeneko/forgetting/raw/branch/main/install.sh)
+bash <(curl -Ls https://raw.githubusercontent.com/maeneko/forgetting/main/install.sh)
 ```
 
 Установщик по умолчанию ставит сервер на AmneziaWG 3.1. Если модуль в ядре
@@ -36,7 +38,7 @@ bash <(curl -Ls https://git.ma7neko.ru/maeneko/forgetting/raw/branch/main/instal
 на 2.0 можно так:
 
 ```bash
-AWG_GEN=auto bash <(curl -Ls https://git.ma7neko.ru/maeneko/forgetting/raw/branch/main/install.sh)
+AWG_GEN=auto bash <(curl -Ls https://raw.githubusercontent.com/maeneko/forgetting/main/install.sh)
 ```
 
 Перевести такой сервер на 3.1 позже можно кнопкой «Перейти на AWG 3.1» в панели —
@@ -149,7 +151,7 @@ TOKEN=$(curl -s -X POST http://HOST:PORT/login \
 
 | Метод | Ответ |
 |---|---|
-| `GET /ui/brand` | `{ "brand": "Forgetting", "channel": "Beta", "version": "0.3.4" }` — **без авторизации**, панель берёт отсюда вордмарк на экране логина |
+| `GET /ui/brand` | `{ "brand": "Forgetting", "channel": "Beta", "version": "0.4.3" }` — **без авторизации**, панель берёт отсюда вордмарк на экране логина |
 | `GET /health` | `{ "status", "server", "ip", "gen", "awg": { "status", "peers", "module", "tools" } }`. `200`, если интерфейс поднят, иначе `503` и `status: "degraded"` |
 | `GET /awg/status` | `{ "up": true, "peers": 3, "publicKey": "…" }` |
 

awg-agent/package.json

@@ -1,6 +1,6 @@
 {
   "name": "awg-agent",
-  "version": "0.3.4",
+  "version": "0.4.3",
   "private": true,
   "description": "Агент ноды: держит исходящее WSS-соединение к core и исполняет запросы на локальном awg-ctrl",
   "scripts": {

awg-ctrl/index.ts

@@ -1,15 +1,16 @@
 // Copyright (c) 2026 Ivan Vasilev
 // This source code is licensed under the MIT license found in the
 // LICENSE file in the root directory of this source tree.
-import fs, { readFileSync, writeFileSync, existsSync, mkdirSync } from "fs";
+import fs, { readFileSync, writeFileSync, existsSync, mkdirSync, openSync, closeSync } from "fs";
 import path  from "path";
 import os   from "os";
 import crypto from "crypto";
-import { execSync, spawnSync } from "child_process";
+import { execSync, spawnSync, execFile, spawn } from "child_process";
 import * as zlib from "zlib";
 import express, { Request, Response, NextFunction } from "express";
 import Database from "better-sqlite3";
 import winston from "winston";
+import { createShaping } from "./shaping";
 
 const logsDir = path.join(process.cwd(), "logs");
 if (!existsSync(logsDir)) mkdirSync(logsDir, { recursive: true });
@@ -575,6 +576,26 @@ function getPeersData(): Record<string, { online: boolean; lastHandshake: number
     } catch (e) { logger.warn("getPeersData failed", { error: e }); return {}; }
 }
 
+// Шейпинг (CAKE) и сэмплер тяжёлых устройств. Счётчики читаем асинхронно: цикл
+// не должен блокировать event loop, как это делают остальные вызовы awg.
+const shaping = createShaping({
+    iface:  CONFIG.interface,
+    getCfg, setCfg, logger,
+    // CAKE видит только внутренний IP-пакет, на проводе к нему добавляются
+    // IPv4 (20) + UDP (8) + заголовок WG (32) = 60 байт и случайный префикс S4.
+    // Формулу сверять iperf3-замером на стенде (SHAPE_OVERHEAD перекрывает её).
+    overhead: () => 60 + (Number(CONFIG.awgParams.S4) || 0),
+    peers: () => new Promise((resolve, reject) => {
+        execFile("awg", ["show", CONFIG.interface, "dump"], { encoding: "utf8", timeout: 10_000 }, (err, out) => {
+            if (err) { reject(err); return; }
+            const rows = out.split("\n").slice(1).map(l => l.split("\t"))
+                .filter(f => f[0] && f[3])
+                .map(f => ({ ip: f[3].split(",")[0].split("/")[0], rx: Number(f[5]) || 0, tx: Number(f[6]) || 0 }));
+            resolve(rows);
+        });
+    }),
+});
+
 function rebuildConf() {
     const users    = db.prepare("SELECT name, ip, pub_key, psk_key FROM users").all() as UserRow[];
     const devices  = stmts.peersAll.all();
@@ -680,6 +701,7 @@ function restartAwg() {
     // в [Peer]-блоки, которые rebuildConf() пересобирает прямо сейчас.
     const gen = reloadAwgParams();
     syncPeers();
+    void shaping.apply();   // tc-правила жили на интерфейсе, который мы только что пересоздали
     const versions = readAwgVersions();
     CONFIG.awgModule = versions.module;
     CONFIG.awgTools  = versions.tools;
@@ -803,6 +825,7 @@ function startInterface() {
     const r = spawnSync("awg-quick", ["up", CONFIG.interface]);
     if (r.status !== 0) throw new Error(`awg-quick up failed: ${r.stderr?.toString()}`);
     syncPeers();
+    void shaping.apply();
     return getInterfaceStatus();
 }
 
@@ -849,12 +872,30 @@ function addUser(username: string): UserRow {
     };
 }
 
+// Снять пира с интерфейса и убедиться, что его там нет. Раньше результат `awg set … remove`
+// не проверялся: строку из базы удаляли, а пир в ядре оставался живым, и про него уже никто не
+// знал. Теперь порядок такой: сначала ядро, потом база — при отказе строка остаётся, и
+// повторная попытка (надгробие панели, следующий sync) найдёт пира.
+function kernelPeers(): Set<string> | null {
+    const r = spawnSync("awg", ["show", CONFIG.interface, "peers"]);
+    return r.status === 0 ? new Set(r.stdout.toString().split("\n").map(l => l.trim()).filter(Boolean)) : null;
+}
+
+function dropFromKernel(pub: string): boolean {
+    const r = spawnSync("awg", ["set", CONFIG.interface, "peer", pub, "remove"]);
+    if (r.status === 0) return true;
+    const left = kernelPeers();
+    if (left && !left.has(pub)) return true;     // ответ странный, но пира уже нет
+    logger.error("peer remove from kernel failed", { pub, stderr: r.stderr?.toString() });
+    return false;
+}
+
 function removeUser(username: string) {
     const user = stmts.get.get(username);
     if (!user) throw new Error("Пользователь не найден");
 
+    if (!dropFromKernel(user.pub_key)) throw new Error("Не удалось снять пира с интерфейса");
     stmts.delete.run(username);
-    spawnSync("awg", ["set", CONFIG.interface, "peer", user.pub_key, "remove"]);
     rebuildConf();
 
     for (const ext of [".conf", ".key"]) {
@@ -920,7 +961,9 @@ function replacePeer(oldPub: string, newPub: string): { ip: string; psk_key: str
         stmts.peerRekey.run(oldPub, newPub);
         throw new Error(`awg set failed: ${r.stderr?.toString()}`);
     }
-    spawnSync("awg", ["set", CONFIG.interface, "peer", oldPub, "remove"]);
+    // Старый ключ не снялся — пир остаётся «призраком» в ядре до аудита панели; смену ключа не откатываем:
+    // новый уже стоит, а клиент к этому моменту получил бы ошибку.
+    if (!dropFromKernel(oldPub)) logger.error("peer rekey: старый ключ остался в ядре", { owner: old.owner });
     rebuildConf();
     logger.info("peer rekeyed", { owner: old.owner, ip: old.ip });
     return { ip: old.ip, psk_key: old.psk_key };
@@ -941,8 +984,8 @@ function rotatePeerPsk(pub: string): { ip: string; psk_key: string } {
 function removePeer(pub: string) {
     const peer = stmts.peerGet.get(pub);
     if (!peer) throw new HttpError(404, "Пир не найден");
+    if (!dropFromKernel(pub)) throw new Error("Не удалось снять пира с интерфейса");
     stmts.peerDelete.run(pub);
-    spawnSync("awg", ["set", CONFIG.interface, "peer", pub, "remove"]);
     rebuildConf();
     logger.info("peer removed", { owner: peer.owner });
 }
@@ -964,18 +1007,15 @@ function syncOwnedPeers(panel: string, keep: string[]): {
     const prefix = panel + "/";
     const removed: PeerRow[] = [];
     let claimed = 0;
-    db.transaction(() => {
-        for (const p of stmts.peersAll.all()) {
-            if (p.owner.startsWith(prefix)) {
-                if (!want.has(p.pub_key)) { stmts.peerDelete.run(p.pub_key); removed.push(p); }
-            } else if (LEGACY_OWNER.test(p.owner) && want.has(p.pub_key)) {
-                stmts.peerOwner.run(prefix + p.owner, p.pub_key);
-                claimed++;
-            }
+    for (const p of stmts.peersAll.all()) {
+        if (p.owner.startsWith(prefix)) {
+            // Ядро первым: не снялся — строка остаётся, следующий sync попробует снова.
+            if (!want.has(p.pub_key) && dropFromKernel(p.pub_key)) { stmts.peerDelete.run(p.pub_key); removed.push(p); }
+        } else if (LEGACY_OWNER.test(p.owner) && want.has(p.pub_key)) {
+            stmts.peerOwner.run(prefix + p.owner, p.pub_key);
+            claimed++;
         }
-    })();
-
-    for (const p of removed) spawnSync("awg", ["set", CONFIG.interface, "peer", p.pub_key, "remove"]);
+    }
     if (removed.length || claimed) rebuildConf();
     if (removed.length) logger.info("peers synced out", { panel, removed: removed.map(p => p.owner) });
 
@@ -992,7 +1032,9 @@ const app = express();
 const SYNC_PATH = "/api/peers/sync";
 const jsonSmall = express.json({ limit: "1kb" });
 const jsonSync  = express.json({ limit: "512kb" });
-app.use((req, res, next) => (req.path === SYNC_PATH ? jsonSync : jsonSmall)(req, res, next));
+// /api/audit/clean тоже несёт до SYNC_MAX ключей — под 1kb он принимал бы около двадцати.
+const BIG_BODY_PATHS = new Set([SYNC_PATH, "/api/audit/clean"]);
+app.use((req, res, next) => (BIG_BODY_PATHS.has(req.path) ? jsonSync : jsonSmall)(req, res, next));
 
 function verifyInternalToken(token: string): boolean {
     try {
@@ -1075,6 +1117,8 @@ app.get("/api/users/stats", auth, handler((_req, res) => {
             lastHandshake: peers[u.pub_key]?.lastHandshake ?? 0,
             rx:            peers[u.pub_key]?.rx            ?? 0,
             tx:            peers[u.pub_key]?.tx            ?? 0,
+            // «normal» | «background»: фоновый — пока канал занят, а устройство давно качает больше своей доли
+            priority:      shaping.priorityOf(u.ip),
         })),
     });
 }));
@@ -1111,10 +1155,43 @@ app.get("/api/peers", auth, handler((_req, res) => {
             lastHandshake: stats[p.pub_key]?.lastHandshake ?? 0,
             rx:            stats[p.pub_key]?.rx            ?? 0,
             tx:            stats[p.pub_key]?.tx            ?? 0,
+            priority:      shaping.priorityOf(p.ip),
         })),
     });
 }));
 
+// Пиры, которые стоят в ядре, но неизвестны awg-ctrl (нет ни в users, ни в peers): снять их
+// после сбоя `awg set … remove` некому. Только чтение — панель (core) сама решает, что делать.
+app.get("/api/audit", auth, handler((_req, res) => {
+    const r = spawnSync("awg", ["show", CONFIG.interface, "dump"]);
+    if (r.status !== 0) throw new HttpError(503, "awg show не ответил");
+    const known = new Set<string>([
+        ...(db.prepare("SELECT pub_key FROM users").all() as { pub_key: string }[]).map(u => u.pub_key),
+        ...stmts.peersAll.all().map(p => p.pub_key),
+    ]);
+    const now = Math.floor(Date.now() / 1000);
+    const ghosts = r.stdout.toString().split("\n").slice(1).map(l => l.split("\t")).filter(f => f[0] && !known.has(f[0])).map(f => {
+        const lastHandshake = Number(f[4]) || 0;
+        return { pub_key: f[0], lastHandshake, online: lastHandshake > 0 && now - lastHandshake < 180, rx: Number(f[5]) || 0, tx: Number(f[6]) || 0 };
+    });
+    res.json({ ghosts });
+}));
+
+// Снять «призраков» из ядра. Ключи присылает панель, но здесь каждый перепроверяется: пир, который
+// успел появиться в users/peers, не трогаем. Строк в базе у «призраков» нет — снимается только ядро.
+app.post("/api/audit/clean", auth, handler((req, res) => {
+    const { pub_keys } = (req.body ?? {}) as { pub_keys?: unknown };
+    if (!Array.isArray(pub_keys) || pub_keys.length > SYNC_MAX) throw new HttpError(400, "Неверный список ключей");
+    const removed: string[] = [], skipped: string[] = [];
+    for (const k of pub_keys.map(checkPubKey)) {
+        const known = stmts.peerGet.get(k) || (db.prepare("SELECT 1 FROM users WHERE pub_key = ?").get(k));
+        if (known || k === getServerPublicKey() || !kernelPeers()?.has(k)) { skipped.push(k); continue; }
+        (dropFromKernel(k) ? removed : skipped).push(k);
+    }
+    if (removed.length) logger.warn("ghost peers removed from kernel", { count: removed.length, removed });
+    res.json({ removed, skipped });
+}));
+
 // Должен стоять ДО PUT /api/peers/:pub — иначе тот примет «sync» за ключ.
 app.put(SYNC_PATH, auth, handler((req, res) => {
     const { owner, keep } = (req.body ?? {}) as { owner?: unknown; keep?: unknown };
@@ -1175,6 +1252,148 @@ app.post("/awg/upgrade", auth, handler((_req, res) => {
     }
 }));
 
+// Деление канала между устройствами. Путь под /api/ — иначе awg-agent на ноде его не пропустит
+// (и без PATCH: агент отвечает на него 400).
+app.get("/api/shaping", auth, handler(async (_req, res) => {
+    res.json(await shaping.status());
+}));
+
+app.put("/api/shaping", auth, handler(async (req, res) => {
+    const b = (req.body ?? {}) as Record<string, unknown>;
+    const mbit = (v: unknown, what: string): number => {
+        const n = Number(v);
+        if (!Number.isInteger(n) || n < 0 || n > 100_000) throw new HttpError(400, `${what}: целое число Мбит/с от 1 до 100000`);
+        return n;
+    };
+    if (typeof b.enabled !== "boolean" || typeof b.auto !== "boolean")
+        throw new HttpError(400, "enabled и auto должны быть true/false");
+    const downMbit = mbit(b.downMbit ?? 0, "Загрузка");
+    const upMbit   = mbit(b.upMbit   ?? 0, "Отдача");
+    if (b.enabled && (downMbit < 1 || upMbit < 1))
+        throw new HttpError(400, "Для включения укажите ширину канала в обе стороны");
+    try {
+        await shaping.update({ enabled: b.enabled, auto: b.auto, downMbit, upMbit });
+    } catch (e) {
+        // tc/nft/модуль не нашлись или ядро отказало: оператору нужна причина, а не 500.
+        throw new HttpError(500, e instanceof Error ? e.message : "Не удалось применить шейпинг");
+    }
+    res.json(await shaping.status());
+}));
+
+// Метрики для Prometheus. awg-ctrl отдаёт JSON, а текстовый формат собирает awg-ui: на ноде
+// агент пропускает только /api/*, и один формат на ядре и нодах проще сверять. Кэш на 5 с —
+// несколько скрейперов не должны гонять `awg show` чаще.
+const METRICS_TTL_MS = 5_000;
+let metricsCache: { at: number; data: Promise<unknown> } | null = null;
+
+function linkCounter(name: string): number {
+    try { return Number(readFileSync(`/sys/class/net/${CONFIG.interface}/statistics/${name}`, "utf8")) || 0; }
+    catch { return 0; }
+}
+
+// Нагрузка хоста из /proc. Счётчики CPU кумулятивные (секунды по режимам, как у node_exporter): долю считает
+// Prometheus через rate(), здесь мгновенного «процента» нет. Память — MemAvailable, а не MemFree: кэш ядра свободен.
+const CPU_MODES = ["user", "nice", "system", "idle", "iowait", "irq", "softirq", "steal"] as const;
+function readHost() {
+    try {
+        const first = readFileSync("/proc/stat", "utf8").split("\n")[0].trim().split(/\s+/).slice(1).map(Number);
+        const cpu: Record<string, number> = {};
+        CPU_MODES.forEach((m, i) => { cpu[m] = (first[i] || 0) / 100; });     // USER_HZ = 100 на всех обычных ядрах
+        const mem = readFileSync("/proc/meminfo", "utf8");
+        const kb = (k: string) => Number(mem.match(new RegExp(`^${k}:\\s+(\\d+) kB`, "m"))?.[1] ?? 0) * 1024;
+        return {
+            cpu, cores: os.cpus().length, load: os.loadavg(),
+            mem: { total: kb("MemTotal"), available: kb("MemAvailable") },
+        };
+    } catch { return null; }
+}
+
+async function collectMetrics() {
+    const st    = getInterfaceStatus();
+    const stats = st.up ? getPeersData() : {};
+    const list: { kind: "user" | "device"; name: string; ip: string; online: boolean; rx: number; tx: number; priority: string }[] = [
+        ...(db.prepare("SELECT name, ip, pub_key FROM users WHERE vpn_key != ''").all() as UserRow[]).map(u => ({
+            kind: "user" as const, name: u.name, ip: u.ip,
+            online: stats[u.pub_key]?.online ?? false, rx: stats[u.pub_key]?.rx ?? 0, tx: stats[u.pub_key]?.tx ?? 0,
+            priority: shaping.priorityOf(u.ip),
+        })),
+        ...stmts.peersAll.all().map(p => ({
+            kind: "device" as const, name: "", ip: p.ip,
+            online: stats[p.pub_key]?.online ?? false, rx: stats[p.pub_key]?.rx ?? 0, tx: stats[p.pub_key]?.tx ?? 0,
+            priority: shaping.priorityOf(p.ip),
+        })),
+    ];
+    const all = Object.values(stats);
+    return {
+        up:    st.up,
+        gen:   CONFIG.gen,
+        peers: { total: st.peers, online: all.filter(p => p.online).length },
+        // С точки зрения сервера: rx — принято от клиентов (их отдача), tx — отправлено клиентам (их загрузка).
+        rx_bytes: all.reduce((a, p) => a + p.rx, 0),
+        tx_bytes: all.reduce((a, p) => a + p.tx, 0),
+        link: {
+            rx_bytes: linkCounter("rx_bytes"), tx_bytes: linkCounter("tx_bytes"),
+            rx_packets: linkCounter("rx_packets"), tx_packets: linkCounter("tx_packets"),
+            rx_dropped: linkCounter("rx_dropped"), tx_dropped: linkCounter("tx_dropped"),
+            rx_errors: linkCounter("rx_errors"), tx_errors: linkCounter("tx_errors"),
+        },
+        shaping: await shaping.status(),
+        host:    readHost(),
+        list,
+    };
+}
+
+app.get("/api/metrics", auth, handler(async (_req, res) => {
+    if (!metricsCache || Date.now() - metricsCache.at > METRICS_TTL_MS) {
+        const data = collectMetrics();
+        metricsCache = { at: Date.now(), data };
+        data.catch(() => { metricsCache = null; });      // ошибку не кэшируем
+    }
+    res.json(await metricsCache.data);
+}));
+
+// Установка и удаление встроенного мониторинга (Prometheus) по кнопке в панели. Действие одно из двух и без
+// параметров: awg-ctrl запускает ту же команду, что оператор набрал бы руками (`awg-ctrl monitor install|remove`,
+// root), так что код один. Панель сама пакетов не ставит и не удаляет — она только просит об этом здесь.
+const MONITOR_CLI = process.env.AWG_CLI ?? "/usr/local/bin/awg-ctrl";
+const MONITOR_LOG = process.env.MONITOR_LOG ?? path.resolve(process.cwd(), "..", "logs", "monitor-job.log");
+type MonitorAction = "install" | "remove";
+let monitorJob: { action: MonitorAction; startedAt: number; exit: number | null } | null = null;
+
+const logTail = (): string => {
+    try {
+        const t = readFileSync(MONITOR_LOG, "utf8").slice(-4000);
+        // apt рисует прогресс возвратом каретки и цветами — в панели это мусор
+        return t.replace(/\x1b\[[0-9;]*[A-Za-z]/g, "").replace(/\r/g, "\n");
+    } catch { return ""; }
+};
+
+function startMonitorJob(action: MonitorAction, res: Response) {
+    if (monitorJob && monitorJob.exit === null) { res.status(409).json({ error: "Операция уже идёт" }); return; }
+    if (!existsSync(MONITOR_CLI)) throw new HttpError(501, `CLI не найден (${MONITOR_CLI}): выполните на сервере awg-ctrl monitor ${action}`);
+    mkdirSync(path.dirname(MONITOR_LOG), { recursive: true });
+    const fd  = openSync(MONITOR_LOG, "w");
+    const job = { action, startedAt: Date.now(), exit: null as number | null };
+    monitorJob = job;
+    const done = (code: number) => { job.exit = code; try { closeSync(fd); } catch { /* уже закрыт */ } };
+    const child = spawn(MONITOR_CLI, ["monitor", action], { stdio: ["ignore", fd, fd] });
+    child.on("error", e => { logger.error("monitor: не запустился", { action, error: e.message }); done(127); });
+    child.on("exit", code => { logger.info("monitor: завершён", { action, code }); done(code ?? 1); });
+    res.status(202).json({ running: true, action });
+}
+
+app.post("/api/monitor/install", auth, handler((_req, res) => { startMonitorJob("install", res); }));
+app.post("/api/monitor/remove",  auth, handler((_req, res) => { startMonitorJob("remove", res); }));
+
+app.get("/api/monitor/job", auth, handler((_req, res) => {
+    res.json({
+        action: monitorJob?.action ?? null,
+        running: !!monitorJob && monitorJob.exit === null,
+        exit: monitorJob?.exit ?? null,
+        log: monitorJob ? logTail() : "",
+    });
+}));
+
 app.get("/awg/status", auth, handler((_req, res) => {
     res.json(getInterfaceStatus());
 }));
@@ -1188,3 +1407,7 @@ app.listen(SERVER.port, "127.0.0.1", () => {
 });
 ensureInterfaceUp();
 syncPeers();
+// Обязательно и на старте: при загрузке интерфейс поднимает systemd (ExecStartPre),
+// ни один из путей awg-quick up внутри awg-ctrl тогда не срабатывает.
+void shaping.apply();
+shaping.start();

awg-ctrl/package.json

@@ -1,6 +1,6 @@
 {
   "name": "awg-control",
-  "version": "0.3.4",
+  "version": "0.4.3",
   "description": "",
   "main": "dist/index.js",
   "scripts": {

awg-ctrl/shaping.ts

@@ -0,0 +1,338 @@
+// Честное деление канала между устройствами (CAKE) + автоподстройка по RFC 6057.
+//
+// Схема:
+//   загрузка (к клиенту)  — CAKE root на awg1, dual-dsthost, diffserv3
+//   отдача (от клиента)   — ingress awg1 → ifb-awg, CAKE dual-srchost, besteffort
+//   тяжёлые при перегрузке — DSCP CS1 (bulk-tin CAKE) через отдельную nft-таблицу
+//
+// Ничего не пишет в awg1.conf (PostUp не трогаем): всё применяется из процесса и
+// идемпотентно. Правила tc пропадают вместе с интерфейсом, поэтому apply() зовётся
+// на старте, после restartAwg()/startInterface() и из страховочной проверки в цикле.
+//
+// Сэмплер только КЛАССИФИЦИРУЕТ. Он никого не удаляет и не отключает — ни по
+// времени, ни по неактивности (правило проекта: удаление только по явному списку
+// от панели).
+import { execFile, spawn } from "child_process";
+import type { Logger } from "winston";
+
+export interface ShapingSettings {
+    enabled:  boolean;
+    downMbit: number;
+    upMbit:   number;
+    auto:     boolean;
+}
+
+export interface PeerCounters {
+    ip: string;
+    rx: number;   // принято от клиента (его отдача)
+    tx: number;   // отправлено клиенту (его загрузка)
+}
+
+export interface ShapingDeps {
+    iface:    string;
+    getCfg:   (key: string, fallback: string) => string;
+    setCfg:   (key: string, value: string) => void;
+    logger:   Pick<Logger, "info" | "warn" | "error">;
+    // Байт на пакет, которые туннель добавляет на проводе (CAKE видит только внутренний IP-пакет).
+    overhead: () => number;
+    peers:    () => Promise<PeerCounters[]>;
+}
+
+export interface QdiscStats { packets: number; bytes: number; drops: number; backlog: number }
+
+export interface ShapingStatus {
+    settings:  ShapingSettings;
+    active:    boolean;               // CAKE реально стоит на интерфейсе
+    congested: boolean;
+    heavy:     string[];              // IP устройств в bulk-классе
+    devices:   number;                // активных устройств в окне
+    rateDown:  number;                // Мбит/с за последний тик
+    rateUp:    number;
+    down?:     QdiscStats;
+    up?:       QdiscStats;
+}
+
+// Окна и пороги. Переопределение через env — только для тестов на стенде.
+const num = (v: string | undefined, d: number) => (v && Number.isFinite(Number(v)) && Number(v) > 0 ? Number(v) : d);
+const SAMPLE_S       = num(process.env.SHAPE_SAMPLE_S, 10);
+const WINDOW_S       = num(process.env.SHAPE_WINDOW_S, 600);
+const CONGEST_ON     = 0.85;   // доля ширины, выше которой канал считается перегруженным
+const CONGEST_OFF    = 0.70;   // и ниже которой перегрузка снимается (гистерезис)
+const ACTIVE_MBIT    = 0.1;    // меньше — устройство не считается активным
+const HEAVY_MULT     = 1.5;    // тяжёлое: ≥ 1.5 честных долей…
+const HEAVY_MIN_FRAC = 0.05;   // …и не меньше 5% ширины канала
+const CHECK_EVERY    = 3;      // страховочная проверка qdisc — раз в N тиков
+
+const IFB  = "ifb-awg";
+const NFT_TABLE = "awg_shape";
+
+function exec(cmd: string, args: string[]): Promise<string> {
+    return new Promise((resolve, reject) => {
+        execFile(cmd, args, { encoding: "utf8", timeout: 15_000 }, (err, stdout, stderr) => {
+            if (err) reject(new Error(`${cmd} ${args.join(" ")}: ${(stderr || err.message).toString().trim()}`));
+            else resolve(stdout);
+        });
+    });
+}
+
+function execStdin(cmd: string, args: string[], input: string): Promise<void> {
+    return new Promise((resolve, reject) => {
+        const p = spawn(cmd, args, { stdio: ["pipe", "ignore", "pipe"] });
+        let err = "";
+        p.stderr.on("data", d => { err += d; });
+        p.stdin.on("error", () => undefined);   // процесс умер раньше, чем дочитал stdin — причина придёт в close
+        p.on("error", reject);
+        p.on("close", code => code === 0 ? resolve() : reject(new Error(`${cmd}: ${err.trim() || `exit ${code}`}`)));
+        p.stdin.end(input);
+    });
+}
+
+interface Tick { dt: number; bytes: number }
+
+export function createShaping(deps: ShapingDeps) {
+    const { iface, logger } = deps;
+
+    // ───────────── настройки ─────────────
+    function settings(): ShapingSettings {
+        return {
+            enabled:  deps.getCfg("shapeEnabled", "0") === "1",
+            downMbit: Number(deps.getCfg("shapeDownMbit", "0")) || 0,
+            upMbit:   Number(deps.getCfg("shapeUpMbit", "0")) || 0,
+            auto:     deps.getCfg("shapeAuto", "1") === "1",
+        };
+    }
+
+    function save(s: ShapingSettings) {
+        deps.setCfg("shapeEnabled",  s.enabled ? "1" : "0");
+        deps.setCfg("shapeDownMbit", String(s.downMbit));
+        deps.setCfg("shapeUpMbit",   String(s.upMbit));
+        deps.setCfg("shapeAuto",     s.auto ? "1" : "0");
+    }
+
+    // ───────────── применение ─────────────
+    // Все изменения tc/nft идут строго по одному: два параллельных apply() дали бы
+    // полусобранные qdisc.
+    let chain: Promise<unknown> = Promise.resolve();
+    const serial = <T>(fn: () => Promise<T>): Promise<T> => {
+        const r = chain.then(fn, fn);
+        chain = r.catch(() => undefined);
+        return r;
+    };
+
+    let lastError = "";
+    const noteError = (e: unknown) => {
+        const m = e instanceof Error ? e.message : String(e);
+        if (m !== lastError) logger.warn("shaping: " + m);   // одинаковую ошибку в лог не спамим
+        lastError = m;
+    };
+
+    const cakeOverhead = () => {
+        const o = Number(process.env.SHAPE_OVERHEAD);
+        return Number.isFinite(o) && o >= 0 && process.env.SHAPE_OVERHEAD ? o : deps.overhead();
+    };
+
+    async function nftApply(heavy: string[]) {
+        const elements = heavy.length ? `\n        elements = { ${heavy.join(", ")} }` : "";
+        // add+delete в одной транзакции: таблица пересоздаётся атомарно, без окна без правил.
+        await execStdin("nft", ["-f", "-"], `
+add table inet ${NFT_TABLE}
+delete table inet ${NFT_TABLE}
+table inet ${NFT_TABLE} {
+    set heavy {
+        type ipv4_addr${elements}
+    }
+    chain postrouting {
+        type filter hook postrouting priority -150; policy accept;
+        oifname "${iface}" ip daddr @heavy ip dscp set cs1
+    }
+}
+`);
+    }
+
+    async function hasCake(dev: string): Promise<boolean> {
+        try { return /\bcake\b/.test(await exec("tc", ["qdisc", "show", "dev", dev, "root"])); }
+        catch { return false; }
+    }
+
+    async function hasIngressRedirect(): Promise<boolean> {
+        try { return /mirred/.test(await exec("tc", ["filter", "show", "dev", iface, "parent", "ffff:"])); }
+        catch { return false; }
+    }
+
+    async function applyNow() {
+        const s = settings();
+        if (!s.enabled || s.downMbit <= 0 || s.upMbit <= 0) { await removeNow(); return; }
+        const oh = cakeOverhead();
+
+        // Загрузка (к клиенту). replace = change, если qdisc уже стоит: скорость меняется на лету.
+        await exec("tc", ["qdisc", "replace", "dev", iface, "root", "cake",
+            "bandwidth", `${s.downMbit}mbit`, "diffserv3", "dual-dsthost", "overhead", String(oh)]);
+
+        // Отдача (от клиента): зеркалим входящий трафик awg1 на ifb и делим там.
+        try { await exec("ip", ["link", "show", IFB]); }
+        catch { await exec("ip", ["link", "add", IFB, "type", "ifb"]); }
+        await exec("ip", ["link", "set", IFB, "up"]);
+        await exec("tc", ["qdisc", "replace", "dev", IFB, "root", "cake",
+            "bandwidth", `${s.upMbit}mbit`, "besteffort", "dual-srchost", "overhead", String(oh)]);
+        if (!(await hasIngressRedirect())) {
+            await exec("tc", ["qdisc", "del", "dev", iface, "ingress"]).catch(() => undefined);
+            await exec("tc", ["qdisc", "add", "dev", iface, "handle", "ffff:", "ingress"]);
+            await exec("tc", ["filter", "add", "dev", iface, "parent", "ffff:", "protocol", "all", "prio", "1",
+                "matchall", "action", "mirred", "egress", "redirect", "dev", IFB]);
+        }
+
+        await nftApply([...heavySet]);
+        lastError = "";
+        logger.info("shaping applied", { down: s.downMbit, up: s.upMbit, overhead: oh, heavy: heavySet.size });
+    }
+
+    async function removeNow() {
+        await exec("tc", ["qdisc", "del", "dev", iface, "root"]).catch(() => undefined);
+        await exec("tc", ["qdisc", "del", "dev", iface, "ingress"]).catch(() => undefined);
+        await exec("ip", ["link", "del", IFB]).catch(() => undefined);
+        await exec("nft", ["delete", "table", "inet", NFT_TABLE]).catch(() => undefined);
+        heavySet.clear(); history.clear(); totals.length = 0; congested = false;
+    }
+
+    // Не бросает: отсутствие tc/nft/модуля не должно валить awg-ctrl (в отличие от ensureInterfaceUp).
+    function apply(): Promise<void> {
+        return serial(applyNow).catch(noteError);
+    }
+
+    async function update(s: ShapingSettings): Promise<void> {
+        save(s);
+        await serial(applyNow);     // пользователю нужна честная ошибка, а не молчаливый warn
+        lastError = "";
+    }
+
+    // ───────────── сэмплер (RFC 6057) ─────────────
+    const prev     = new Map<string, { rx: number; tx: number }>();
+    const history  = new Map<string, Tick[]>();     // загрузка по IP
+    const totals: Tick[] = [];                      // суммарная загрузка (всё, что ушло клиентам)
+    const heavySet = new Set<string>();
+    let congested = false;
+    let lastRateDown = 0, lastRateUp = 0;
+    let lastTickAt = 0;
+    let tickNo = 0;
+    const windowTicks = Math.max(3, Math.round(WINDOW_S / SAMPLE_S));
+
+    const push = (arr: Tick[], t: Tick) => { arr.push(t); while (arr.length > windowTicks) arr.shift(); };
+    const mbit = (arr: Tick[]) => {
+        const dt = arr.reduce((a, t) => a + t.dt, 0);
+        return dt > 0 ? arr.reduce((a, t) => a + t.bytes, 0) * 8 / dt / 1e6 : 0;
+    };
+
+    async function tick() {
+        const s = settings();
+        if (!s.enabled) return;
+        const now = Date.now();
+        const dt  = lastTickAt ? (now - lastTickAt) / 1000 : SAMPLE_S;
+        lastTickAt = now;
+        tickNo++;
+
+        // Страховка: интерфейс могли поднять руками (awg-quick down/up) — qdisc тогда исчез.
+        if (tickNo % CHECK_EVERY === 0 && !(await hasCake(iface))) {
+            logger.warn("shaping: qdisc на интерфейсе пропал, применяю заново");
+            await apply();
+        }
+
+        let peers: PeerCounters[];
+        try { peers = await deps.peers(); } catch (e) { noteError(e); return; }
+
+        let totalDown = 0, totalUp = 0;
+        const seen = new Set<string>();
+        for (const p of peers) {
+            seen.add(p.ip);
+            const before = prev.get(p.ip);
+            // Счётчики ядра сбрасываются при down/up интерфейса и замене ключа пира → отрицательная дельта = 0.
+            const dTx = before && p.tx >= before.tx ? p.tx - before.tx : 0;
+            const dRx = before && p.rx >= before.rx ? p.rx - before.rx : 0;
+            prev.set(p.ip, { rx: p.rx, tx: p.tx });
+            totalDown += dTx; totalUp += dRx;
+            let h = history.get(p.ip);
+            if (!h) history.set(p.ip, h = []);
+            push(h, { dt, bytes: dTx });
+        }
+        for (const ip of [...prev.keys()]) if (!seen.has(ip)) { prev.delete(ip); history.delete(ip); heavySet.delete(ip); }
+        push(totals, { dt, bytes: totalDown });
+        lastRateDown = totalDown * 8 / dt / 1e6;
+        lastRateUp   = totalUp   * 8 / dt / 1e6;
+
+        if (!s.auto) {
+            if (heavySet.size || congested) { heavySet.clear(); congested = false; await serial(() => nftApply([])).catch(noteError); }
+            return;
+        }
+        if (totals.length < windowTicks) return;    // пока окно не набралось, решений не принимаем
+
+        const avg = mbit(totals);
+        const wasCongested = congested;
+        if (!congested && avg >= CONGEST_ON  * s.downMbit) congested = true;
+        if ( congested && avg <  CONGEST_OFF * s.downMbit) congested = false;
+
+        const nextHeavy = new Set<string>();
+        let active = 0;
+        if (congested) {
+            const rates = [...history.entries()].filter(([, h]) => h.length >= windowTicks).map(([ip, h]) => [ip, mbit(h)] as const);
+            active = rates.filter(([, r]) => r >= ACTIVE_MBIT).length;
+            const share = s.downMbit / Math.max(1, active);
+            for (const [ip, r] of rates) {
+                const wasHeavy = heavySet.has(ip);
+                // Входим на 1.5 доли, выходим ниже 1.0 доли — без дребезга на границе.
+                if (r >= Math.max(HEAVY_MULT * share, HEAVY_MIN_FRAC * s.downMbit) || (wasHeavy && r >= share)) nextHeavy.add(ip);
+            }
+        }
+
+        const changed = nextHeavy.size !== heavySet.size || [...nextHeavy].some(ip => !heavySet.has(ip));
+        if (changed || wasCongested !== congested) {
+            heavySet.clear(); nextHeavy.forEach(ip => heavySet.add(ip));
+            logger.info("shaping: класс тяжёлых обновлён", { congested, avgMbit: Math.round(avg), heavy: [...heavySet] });
+            await serial(() => nftApply([...heavySet])).catch(noteError);
+        }
+    }
+
+    let timer: NodeJS.Timeout | null = null;
+    function start() {
+        if (timer) return;
+        let busy = false;
+        timer = setInterval(() => {
+            if (busy) return;       // предыдущий тик ещё идёт — пропускаем, а не копим очередь
+            busy = true;
+            tick().catch(noteError).finally(() => { busy = false; });
+        }, SAMPLE_S * 1000);
+        timer.unref();
+    }
+
+    // ───────────── состояние ─────────────
+    async function qdiscStats(dev: string): Promise<QdiscStats | undefined> {
+        try {
+            const arr = JSON.parse(await exec("tc", ["-s", "-j", "qdisc", "show", "dev", dev, "root"])) as Record<string, unknown>[];
+            const q = arr.find(x => x.kind === "cake");
+            if (!q) return undefined;
+            return {
+                packets: Number(q.packets) || 0, bytes: Number(q.bytes) || 0,
+                drops:   Number(q.drops)   || 0, backlog: Number(q.backlog) || 0,
+            };
+        } catch { return undefined; }
+    }
+
+    async function status(): Promise<ShapingStatus> {
+        const s = settings();
+        const [active, down, up] = s.enabled
+            ? await Promise.all([hasCake(iface), qdiscStats(iface), qdiscStats(IFB)])
+            : [false, undefined, undefined];
+        return {
+            settings: s, active, congested, heavy: [...heavySet],
+            devices:  [...history.values()].filter(h => mbit(h) >= ACTIVE_MBIT).length,
+            rateDown: Math.round(lastRateDown * 10) / 10,
+            rateUp:   Math.round(lastRateUp   * 10) / 10,
+            down, up,
+        };
+    }
+
+    // Текущий приоритет устройства по его внутреннему IP: «фоновый» — пока он в bulk-классе.
+    const priorityOf = (ip: string): "normal" | "background" => (heavySet.has(ip) ? "background" : "normal");
+
+    return { settings, update, apply, start, status, priorityOf };
+}
+
+export type Shaping = ReturnType<typeof createShaping>;

awg-ui/metrics.ts

@@ -0,0 +1,235 @@
+// Copyright (c) 2026 Ivan Vasilev
+// This source code is licensed under the MIT license found in the
+// LICENSE file in the root directory of this source tree.
+//
+// Prometheus: GET /metrics на ядре. Метрики ядра и всех нод собираются здесь же —
+// у нод через уже открытый WSS (awg-agent пропускает только /api/*, поэтому на самих
+// нодах отдельного порта для скрейпа не нужно). Доступ — отдельный токен «только
+// чтение метрик»; он не открывает ни /api/v1, ни панель.
+import crypto from "crypto";
+import fs from "fs";
+import { Router, type Request, type Response, type NextFunction } from "express";
+import type Database from "better-sqlite3";
+
+interface ServerInfo {
+    id: number; name: string; local: boolean; online: boolean; pending: boolean;
+    version: string | null;
+    health: { gen: string; module: string; tools: string } | null;
+}
+
+interface MetricsDeps {
+    uidb:    Database.Database;
+    version: string;
+    servers: {
+        list:    () => ServerInfo[];
+        isOnline: (id: number) => boolean;
+        ctrlFor: (id: number) => (method: string, urlPath: string) => Promise<{ status: number; data: any }>;
+    };
+}
+
+const SCRAPE_DEADLINE_MS = 5_000;
+const TOUCH_EVERY_S      = 60;          // last_used пишем не чаще раза в минуту, а не на каждый скрейп
+
+const hashToken = (t: string) => crypto.createHash("sha256").update(t).digest();
+
+// Токен встроенного Prometheus (`awg-ctrl monitor install`): сам токен лежит только у Prometheus,
+// здесь — его хэш. Файл читаем при каждой проверке, пересчитывая по mtime: установка не требует перезапуска панели.
+const LOCAL_HASH_FILE = process.env.MONITOR_HASH_FILE ?? "/etc/amnezia/amneziawg/monitor_token.sha256";
+let localHash: { mtime: number; hash: Buffer | null } = { mtime: -1, hash: null };
+function localTokenHash(): Buffer | null {
+    try {
+        const mtime = fs.statSync(LOCAL_HASH_FILE).mtimeMs;
+        if (mtime !== localHash.mtime) {
+            const hex = fs.readFileSync(LOCAL_HASH_FILE, "utf8").trim();
+            localHash = { mtime, hash: /^[0-9a-f]{64}$/.test(hex) ? Buffer.from(hex, "hex") : null };
+        }
+        return localHash.hash;
+    } catch { localHash = { mtime: -1, hash: null }; return null; }
+}
+
+// Пер-пировые серии (метка peer = внутренний IP, name = имя vpn://-пользователя) выключены:
+// это и приватность, и кардинальность. Включается явно.
+const PER_PEER = (process.env.METRICS_PEERS ?? "off").toLowerCase() === "on";
+
+type Labels = Record<string, string | number>;
+type Sample = [Labels, number];
+
+const esc = (v: string | number) => String(v).replace(/\\/g, "\\\\").replace(/\n/g, "\\n").replace(/"/g, '\\"');
+const fmtLabels = (l: Labels) => {
+    const parts = Object.entries(l).map(([k, v]) => `${k}="${esc(v)}"`);
+    return parts.length ? `{${parts.join(",")}}` : "";
+};
+
+class Exposition {
+    private lines: string[] = [];
+    private seen = new Set<string>();
+    add(name: string, type: "gauge" | "counter", help: string, samples: Sample[]) {
+        if (!samples.length) return;
+        if (!this.seen.has(name)) {
+            this.seen.add(name);
+            this.lines.push(`# HELP ${name} ${help.replace(/\\/g, "\\\\").replace(/\n/g, "\\n")}`, `# TYPE ${name} ${type}`);
+        }
+        for (const [l, v] of samples) this.lines.push(`${name}${fmtLabels(l)} ${Number.isFinite(v) ? v : 0}`);
+    }
+    toString() { return this.lines.join("\n") + "\n"; }
+}
+
+export function createMetrics(deps: MetricsDeps) {
+    const { uidb } = deps;
+
+    uidb.exec(`
+        CREATE TABLE IF NOT EXISTS metrics_token (
+            id         INTEGER PRIMARY KEY CHECK (id = 1),
+            token_hash BLOB    NOT NULL,
+            prefix     TEXT    NOT NULL,
+            created_at INTEGER NOT NULL,
+            last_used  INTEGER
+        )
+    `);
+    const q = {
+        get:    uidb.prepare("SELECT token_hash, prefix, created_at, last_used FROM metrics_token WHERE id = 1"),
+        set:    uidb.prepare("INSERT OR REPLACE INTO metrics_token (id, token_hash, prefix, created_at, last_used) VALUES (1, ?, ?, ?, NULL)"),
+        del:    uidb.prepare("DELETE FROM metrics_token WHERE id = 1"),
+        touch:  uidb.prepare("UPDATE metrics_token SET last_used = ? WHERE id = 1"),
+    };
+    type TokenRow = { token_hash: Buffer; prefix: string; created_at: number; last_used: number | null };
+
+    // ── Управление токеном (роуты панели, за JWT) ──
+    const router = Router();
+    const view = () => {
+        const r = q.get.get() as TokenRow | undefined;
+        return r ? { exists: true, prefix: r.prefix, created_at: r.created_at, last_used: r.last_used, per_peer: PER_PEER }
+                 : { exists: false, per_peer: PER_PEER };
+    };
+    router.get("/", (_req: Request, res: Response) => { res.json(view()); });
+    // Выпуск и перевыпуск — одно и то же: старый токен перестаёт работать. Значение отдаётся один раз.
+    router.post("/", (_req: Request, res: Response) => {
+        const token = "awgm_" + crypto.randomBytes(24).toString("base64url");
+        q.set.run(hashToken(token), token.slice(0, 13) + "…", Math.floor(Date.now() / 1000));
+        res.status(201).json({ ...view(), token });
+    });
+    router.delete("/", (_req: Request, res: Response) => { q.del.run(); res.json(view()); });
+
+    // ── Доступ к /metrics ──
+    // Нет токена или он неверный — одинаковый 401: не подсказываем, выключены метрики или токен не тот.
+    function requireToken(req: Request, res: Response, next: NextFunction) {
+        const h = req.headers.authorization ?? "";
+        const given = h.startsWith("Bearer ") ? h.slice(7) : "";
+        const row = q.get.get() as TokenRow | undefined;
+        const gh = given.startsWith("awgm_") ? hashToken(given) : null;
+        const panelOk = !!row && !!gh && crypto.timingSafeEqual(gh, row.token_hash);
+        const local   = localTokenHash();
+        const localOk = !!gh && !!local && crypto.timingSafeEqual(gh, local);
+        if (!panelOk && !localOk) { res.status(401).set("WWW-Authenticate", "Bearer").type("text/plain").send("unauthorized\n"); return; }
+        // last_used — про токен, выпущенный в панели (внешний Prometheus); встроенный в нём не участвует.
+        const now = Math.floor(Date.now() / 1000);
+        if (panelOk && row && (!row.last_used || now - row.last_used >= TOUCH_EVERY_S)) q.touch.run(now);
+        next();
+    }
+
+    // Один сервер за скрейп: сам сервер не отвечает — остальные не страдают.
+    async function scrapeServer(s: ServerInfo): Promise<any | null> {
+        if (s.pending || !deps.servers.isOnline(s.id)) return null;
+        let timer: NodeJS.Timeout | undefined;
+        try {
+            const r = await Promise.race([
+                deps.servers.ctrlFor(s.id)("GET", "/api/metrics"),
+                new Promise<never>((_, rej) => { timer = setTimeout(() => rej(new Error("deadline")), SCRAPE_DEADLINE_MS); }),
+            ]);
+            return r.status === 200 ? r.data : null;
+        } catch { return null; }
+        finally { clearTimeout(timer); }
+    }
+
+    async function render(): Promise<string> {
+        const t0 = process.hrtime.bigint();
+        const list = deps.servers.list();
+        const data = await Promise.all(list.map(scrapeServer));
+        const out = new Exposition();
+        const L = (s: ServerInfo, extra: Labels = {}): Labels => ({ server: s.name, server_id: s.id, ...extra });
+        // Серии только тех серверов, чьи метрики получены; fn всегда отдаёт массив серий.
+        const per = (fn: (s: ServerInfo, d: any) => Sample[]): Sample[] =>
+            list.flatMap((s, i) => (data[i] ? fn(s, data[i]) : []));
+
+        out.add("awg_panel_info", "gauge", "Версия панели Forgetting.", [[{ version: deps.version }, 1]]);
+        out.add("awg_servers", "gauge", "Серверов в панели (ядро и ноды).", [[{}, list.length]]);
+        out.add("awg_server_online", "gauge", "Сервер на связи с панелью (1/0).", list.map(s => [L(s), s.online ? 1 : 0] as Sample));
+        out.add("awg_scrape_ok", "gauge", "Метрики сервера получены в этом скрейпе (1/0).", list.map((s, i) => [L(s), data[i] ? 1 : 0] as Sample));
+        out.add("awg_node_info", "gauge", "Версия Forgetting и поколение AWG на сервере.",
+            list.filter(s => !s.pending).map(s => [L(s, { version: s.version ?? "", gen: s.health?.gen ?? "", module: s.health?.module ?? "", tools: s.health?.tools ?? "" }), 1] as Sample));
+
+        out.add("awg_up", "gauge", "Интерфейс AWG поднят (1/0).", per((s, d) => [[L(s), d.up ? 1 : 0] as Sample]));
+        out.add("awg_peers", "gauge", "Пиров в интерфейсе.", per((s, d) => [[L(s), d.peers?.total ?? 0] as Sample]));
+        out.add("awg_peers_online", "gauge", "Пиров с рукопожатием за последние 3 минуты.", per((s, d) => [[L(s), d.peers?.online ?? 0] as Sample]));
+        // Сумма по пирам — gauge, а не counter: при удалении пира или смене его ключа сумма уменьшается,
+        // и rate() принял бы это за сброс счётчика с ложным всплеском. Для скорости берите awg_link_*_bytes_total.
+        out.add("awg_peers_received_bytes", "gauge", "Принято от клиентов (их отдача), байт, сумма по пирам. Уменьшается при удалении пира.", per((s, d) => [[L(s), d.rx_bytes ?? 0] as Sample]));
+        out.add("awg_peers_sent_bytes", "gauge", "Отправлено клиентам (их загрузка), байт, сумма по пирам. Уменьшается при удалении пира.", per((s, d) => [[L(s), d.tx_bytes ?? 0] as Sample]));
+        for (const [k, name, help] of [
+            ["rx_bytes",   "receive_bytes",    "байт"], ["tx_bytes",   "transmit_bytes",   "байт"],
+            ["rx_packets", "receive_packets",  "пакетов"], ["tx_packets", "transmit_packets", "пакетов"],
+            ["rx_dropped", "receive_dropped",  "потерянных пакетов"], ["tx_dropped", "transmit_dropped", "потерянных пакетов"],
+            ["rx_errors",  "receive_errors",   "ошибок"], ["tx_errors",  "transmit_errors",  "ошибок"],
+        ] as const) {
+            out.add(`awg_link_${name}_total`, "counter", `Интерфейс awg1: ${help} (${k}).`, per((s, d) => [[L(s), d.link?.[k] ?? 0] as Sample]));
+        }
+
+        // Нагрузка хоста (ядро и ноды). CPU — счётчики секунд по режимам: доля = rate() в Prometheus.
+        out.add("awg_host_cpu_seconds_total", "counter", "Время процессора по режимам, секунд (как node_exporter).",
+            per((s, d) => Object.entries(d.host?.cpu ?? {}).map(([mode, v]) => [L(s, { mode }), Number(v)] as Sample)));
+        out.add("awg_host_cpu_cores", "gauge", "Ядер процессора.", per((s, d) => d.host ? [[L(s), d.host.cores ?? 0] as Sample] : []));
+        out.add("awg_host_memory_total_bytes", "gauge", "Оперативной памяти всего, байт.", per((s, d) => d.host ? [[L(s), d.host.mem?.total ?? 0] as Sample] : []));
+        out.add("awg_host_memory_available_bytes", "gauge", "Доступной памяти (MemAvailable), байт.", per((s, d) => d.host ? [[L(s), d.host.mem?.available ?? 0] as Sample] : []));
+        out.add("awg_host_load", "gauge", "Средняя загрузка системы (load average).",
+            per((s, d) => d.host ? (["1m", "5m", "15m"] as const).map((p, i) => [L(s, { period: p }), d.host.load?.[i] ?? 0] as Sample) : []));
+
+        // Деление канала (CAKE)
+        const sh = (fn: (d: any) => number) => per((s, d) => d.shaping ? [[L(s), fn(d.shaping)] as Sample] : []);
+        out.add("awg_shaping_enabled", "gauge", "Деление канала включено в настройках (1/0).", sh(x => x.settings?.enabled ? 1 : 0));
+        out.add("awg_shaping_active", "gauge", "CAKE реально стоит на интерфейсе (1/0).", sh(x => x.active ? 1 : 0));
+        out.add("awg_shaping_congested", "gauge", "Канал считается перегруженным (1/0).", sh(x => x.congested ? 1 : 0));
+        out.add("awg_shaping_heavy_devices", "gauge", "Устройств в фоновом классе.", sh(x => x.heavy?.length ?? 0));
+        out.add("awg_shaping_active_devices", "gauge", "Активных устройств в окне наблюдения.", sh(x => x.devices ?? 0));
+        const dirs = (fn: (x: any, dir: "down" | "up") => number | undefined) =>
+            per((s, d) => d.shaping ? (["down", "up"] as const).flatMap(dir => {
+                const v = fn(d.shaping, dir);
+                return v === undefined ? [] : [[L(s, { direction: dir }), v] as Sample];
+            }) : []);
+        out.add("awg_shaping_bandwidth_bits", "gauge", "Заданная ширина канала, бит/с.", dirs((x, dir) => (dir === "down" ? x.settings?.downMbit : x.settings?.upMbit) * 1e6));
+        out.add("awg_shaping_rate_bits", "gauge", "Скорость за последний тик сэмплера, бит/с.", dirs((x, dir) => (dir === "down" ? x.rateDown : x.rateUp) * 1e6));
+        out.add("awg_shaping_qdisc_drops_total", "counter", "Пакетов, отброшенных CAKE.", dirs((x, dir) => x[dir]?.drops));
+        out.add("awg_shaping_qdisc_backlog_bytes", "gauge", "Байт в очереди CAKE.", dirs((x, dir) => x[dir]?.backlog));
+
+        if (PER_PEER) {
+            const peers = (fn: (p: any) => number) => per((s, d) => (d.list ?? []).map((p: any) =>
+                [L(s, { peer: p.ip, name: p.name ?? "", kind: p.kind }), fn(p)] as Sample));
+            out.add("awg_peer_online", "gauge", "Пир на связи (1/0).", peers(p => p.online ? 1 : 0));
+            out.add("awg_peer_background", "gauge", "Пир в фоновом классе: канал занят, а он давно качает больше своей доли (1/0).", peers(p => p.priority === "background" ? 1 : 0));
+            out.add("awg_peer_received_bytes_total", "counter", "Принято от пира, байт.", peers(p => p.rx));
+            out.add("awg_peer_sent_bytes_total", "counter", "Отправлено пиру, байт.", peers(p => p.tx));
+        }
+
+        let masters = 0, devices = 0;
+        // Таблицы создаёт sub: готовим запросы здесь, а не при создании модуля, — порядок
+        // инициализации в server.ts не должен решать, упадёт ли панель на старте.
+        try {
+            masters = (uidb.prepare("SELECT COUNT(*) AS n FROM master_keys WHERE revoked_at IS NULL").get() as { n: number }).n;
+            devices = (uidb.prepare("SELECT COUNT(*) AS n FROM devices").get() as { n: number }).n;
+        } catch { /* sub ещё не создал таблицы */ }
+        out.add("awg_master_keys", "gauge", "Мастер-ключей sen:// (без удаляемых).", [[{}, masters]]);
+        out.add("awg_devices", "gauge", "Устройств sen://.", [[{}, devices]]);
+        out.add("awg_scrape_duration_seconds", "gauge", "Сколько панель собирала метрики.", [[{}, Number(process.hrtime.bigint() - t0) / 1e9]]);
+        return out.toString();
+    }
+
+    async function handler(_req: Request, res: Response) {
+        try {
+            res.type("text/plain; version=0.0.4; charset=utf-8").send(await render());
+        } catch (e) {
+            console.warn(`metrics: ${(e as Error).message}`);
+            res.status(500).type("text/plain").send("error\n");
+        }
+    }
+
+    return { router, requireToken, handler };
+}

awg-ui/mock-server.ts

@@ -57,7 +57,11 @@ const masters: MK[] = [{ id: mkId++, uuid: crypto.randomUUID(), label: "Семь
 const signPub = crypto.randomBytes(32);
 const mkOut = (m: MK) => ({ id: m.id, uuid: m.uuid, label: m.label, device_limit: m.device_limit, devices: m.devs.length, servers: m.servers, created_at: m.created_at, ...(m.deleting ? { deleting: m.deleting } : {}) });
 // Мок: устройство «догнано» на всех серверах ключа, кроме Tokyo (id 2 — ещё не подключалась).
-const devOut = (m: MK, d: Dev) => ({ ...d, servers_total: m.servers.length, servers_ok: m.servers.filter(s => s !== 2).length });
+const devTorrent = (d: Dev) => !!torrentOf[0]?.enabled && d.id === masters[0]?.devs[1]?.id;
+const devOut = (m: MK, d: Dev) => ({ ...d,
+    priority: shapingOf[0]?.enabled && (d.id === masters[0]?.devs[0]?.id || devTorrent(d)) ? "background" : "normal",
+    torrent: devTorrent(d), servers_total: m.servers.length, servers_ok: m.servers.filter(s => s !== 2).length,
+    ips: m.servers.filter(s => s !== 2).map(s => ({ server_id: s, ip: `10.9.0.${50 + d.id + s * 10}` })) });
 const find = (id: string) => masters.find(m => m.id === Number(id) && !m.deleting);
 
 app.get("/ui/brand", (_q, r) => r.json({ brand: "Forgetting", channel: "Beta", version: MOCK_VERSION }));
@@ -95,8 +99,120 @@ app.delete("/ui/nodes/:id", (q, r) => {
 app.post("/awg/restart", (_q, r) => r.json({ up: true }));
 app.get("/awg/status", (_q, r) => r.json({ up: true, peers: users.length }));
 
+// Монитор: «установка» и «удаление» Prometheus с ходом процесса (как лог CLI на реальном сервере).
+const MON_LOGS = {
+    install: ["1/4  установка пакета prometheus", "Reading package lists…", "Setting up prometheus (2.45.0)…", "2/4  токен и конфиг", "3/4  слушаем только 127.0.0.1:9090, хранение 31d", "4/4  запуск", "✓ Prometheus работает на 127.0.0.1:9090, метрики панели скрейпятся каждые 15 с."],
+    remove:  ["1/3  остановка сервиса", "2/3  токен", "3/3  удаление пакета и накопленных данных", "Removing prometheus (2.45.0)…", "Purging configuration files…", "✓ Prometheus удалён вместе с накопленными графиками."],
+};
+let monJob: { action: "install" | "remove"; start: number } | null = null;
+let monReady = false;
+const MON_MS = 6000;
+const monRunning = () => !!monJob && Date.now() - monJob.start < MON_MS;
+app.get("/ui/monitor", (_q, r) => {
+    if (monJob && !monRunning()) monReady = monJob.action === "install";
+    let job = null;
+    if (monJob) {
+        const lines = MON_LOGS[monJob.action];
+        const n = monRunning() ? Math.max(1, Math.floor(((Date.now() - monJob.start) / MON_MS) * lines.length)) : lines.length;
+        job = { action: monJob.action, running: monRunning(), exit: monRunning() ? null : 0, log: lines.slice(0, n).join("\n") };
+    }
+    r.json({ ready: monReady, can_install: true, command: "awg-ctrl monitor install", job });
+});
+for (const action of ["install", "remove"] as const) {
+    app.post(`/ui/monitor/${action}`, (_q, r) => { if (!monRunning()) monJob = { action, start: Date.now() }; r.status(202).json({ running: true, action }); });
+}
+app.get("/ui/monitor/overview", (q, r) => {
+    const R: Record<string, [number, number]> = { "1h": [3600, 15], "6h": [21600, 60], "24h": [86400, 300], "7d": [604800, 1800], "30d": [2592000, 7200] };
+    const [sec, step] = R[String(q.query.range ?? "1h")] ?? R["1h"];
+    const to = Math.floor(Date.now() / step) * step, from = to - sec;
+    const pts = (f: (i: number, t: number) => number): [number, number][] => Array.from({ length: Math.floor(sec / step) + 1 }, (_, i) => [from + i * step, Math.max(0, f(i, from + i * step))]);
+    const wave = (t: number, per: number, ph = 0) => Math.sin((t / per) * 2 * Math.PI + ph);
+    const per = sec / 3;
+    const down = pts((_, t) => 110e6 + 70e6 * wave(t, per) + 25e6 * wave(t, per / 7) + rnd(12e6));
+    const up   = pts((_, t) => 14e6 + 7e6 * wave(t, per, 1) + rnd(3e6));
+    const online = pts((_, t) => Math.round(9 + 3 * wave(t, per * 1.6) + (rnd(100) > 90 ? 1 : 0)));
+    const heavy  = pts((_, t) => (wave(t, per) > 0.55 ? 1 : 0));
+    const drops  = pts((_, t) => (wave(t, per) > 0.55 ? 3 + rnd(6) : rnd(10) > 8 ? 0.4 : 0));
+    const cpu = pts((_, t) => 38 + 22 * wave(t, per * 0.8, 2) + 12 * wave(t, per / 5) + rnd(6));
+    const mem = pts((_, t) => 54 + 6 * wave(t, per * 3) + rnd(2));
+    const scale = (a: [number, number][], k: number) => a.map(([t, v]) => [t, v * k] as [number, number]);
+    // Один сервер — тот, что выбран в сервер-баре (?server=<id>): ядро (0) или нода
+    const id = Number(q.query.server ?? 0);
+    const k = id === 0 ? 0.7 : 0.3;
+    const down1 = scale(down, k), up1 = scale(up, k);
+    const used = (a: [number, number][]) => a.reduce((n, [, v]) => n + v, 0) * step / 8;   // бит/с × с → байты
+    if (id === 3) return r.json({ range: q.query.range ?? "1h", step, from, to, servers: [], total: { down: [], up: [], online: [], heavy: [], drops: [], cpu: [], mem: [] } });
+    r.json({ range: q.query.range ?? "1h", step, from, to,
+        servers: [{ id, name: id === 0 ? "VPN (mock)" : "Frankfurt", ok: true, down: down1.at(-1)![1], up: up1.at(-1)![1], online: id === 0 ? 7 : 3,
+            heavy: id === 0 ? heavy.at(-1)![1] : 0, congested: id === 0 && heavy.at(-1)![1] > 0,
+            cpu: id === 0 ? cpu.at(-1)![1] : cpu.at(-1)![1] * 0.5, mem: id === 0 ? mem.at(-1)![1] : 31, cores: id === 0 ? 4 : 2, mem_total: (id === 0 ? 4 : 2) * 2 ** 30,
+            used_down: used(down1), used_up: used(up1) }],
+        total: { down: down1, up: up1, online: scale(online, k), heavy: id === 0 ? heavy : scale(heavy, 0), drops: id === 0 ? drops : scale(drops, 0),
+            cpu: id === 0 ? cpu : scale(cpu, 0.5), mem: id === 0 ? mem : scale(mem, 0.55) } });
+});
+
+// Prometheus: токен метрик и сам /metrics (без проверки токена — мок).
+let promTok: { prefix: string; created_at: number; last_used: number | null } | null = null;
+const promView = () => promTok ? { exists: true, ...promTok, per_peer: false } : { exists: false, per_peer: false };
+app.get("/ui/metrics-token", (_q, r) => r.json(promView()));
+app.post("/ui/metrics-token", (_q, r) => {
+    const token = "awgm_" + crypto.randomBytes(24).toString("base64url");
+    promTok = { prefix: token.slice(0, 13) + "…", created_at: now(), last_used: null };
+    r.status(201).json({ ...promView(), token });
+});
+app.delete("/ui/metrics-token", (_q, r) => { promTok = null; r.json(promView()); });
+app.get("/metrics", (_q, r) => r.type("text/plain").send('awg_panel_info{version="mock"} 1\nawg_servers 4\n'));
+
+// Деление канала: состояние по серверам; usersOf[1] играет «старую ноду» без маршрута (404 → «обнови сервер»).
+const shapingOf: Record<number, { enabled: boolean; downMbit: number; upMbit: number; auto: boolean }> = {};
+const shapingView = (id: number) => {
+    const settings = shapingOf[id] ?? { enabled: false, downMbit: 0, upMbit: 0, auto: true };
+    const on = settings.enabled;
+    return {
+        settings, active: on, congested: on && id === 0,
+        heavy: on && id === 0 ? ["10.9.0.2", ...(torrentOf[0]?.enabled ? [TORRENT_IP, "10.9.0.12"] : [])] : [],
+        devices: on ? 7 : 0, rateDown: on ? Math.round(settings.downMbit * 0.9 * 10) / 10 : 0, rateUp: on ? 12.4 : 0,
+    };
+};
+app.get("/api/shaping", (q, r) => srv(q) === 1 ? r.status(404).json({ error: "Not found" }) : r.json(shapingView(srv(q))));
+app.put("/api/shaping", (q, r) => {
+    const id = srv(q), b = q.body ?? {};
+    if (id === 1) return r.status(404).json({ error: "Not found" });
+    if (b.enabled && !(b.downMbit >= 1 && b.upMbit >= 1)) return r.status(400).json({ error: "Для включения укажите ширину канала в обе стороны" });
+    shapingOf[id] = { enabled: !!b.enabled, downMbit: Number(b.downMbit) || 0, upMbit: Number(b.upMbit) || 0, auto: !!b.auto };
+    r.json(shapingView(id));
+});
+
+// Блокировка торрентов: на сервере 0 качает пользователь 10.9.0.3 и второе устройство первого мастер-ключа;
+// Amsterdam (3) изображает старый nftables без TCP-проверки; Frankfurt (1) — старая нода без маршрута (404).
+// Сервер берём прямо из X-Server-Id: srv() подменяет сервер без своих пользователей на 0.
+const torrentOf: Record<number, { enabled: boolean; since: number }> = {};
+const tsid = (q: express.Request) => Number(q.headers["x-server-id"] ?? 0) || 0;
+const TORRENT_IP = "10.9.0.3";
+const torrentSeenIp = (id: number, ip: string) => id === 0 && !!torrentOf[0]?.enabled && ip === TORRENT_IP;
+const torrentView = (id: number) => {
+    const t = torrentOf[id] ?? { enabled: false, since: 0 };
+    const seen = id === 0 && t.enabled
+        ? [{ ip: TORRENT_IP, name: users.find(u => u.ip === TORRENT_IP)?.name ?? "" }, { ip: "10.9.0.12", name: "" }]
+        : [];
+    return { settings: { enabled: t.enabled }, active: t.enabled, tcp: t.enabled && id !== 3,
+        hits: t.enabled && id === 0 ? 1840 + Math.floor((now() - t.since) * 3.7) : 0, seen };
+};
+app.get("/api/torrent", (q, r) => tsid(q) === 1 ? r.status(404).json({ error: "Not found" }) : r.json(torrentView(tsid(q))));
+app.put("/api/torrent", (q, r) => {
+    const id = tsid(q), b = q.body ?? {};
+    if (id === 1) return r.status(404).json({ error: "Not found" });
+    if (typeof b.enabled !== "boolean") return r.status(400).json({ error: "enabled должен быть true/false" });
+    torrentOf[id] = { enabled: b.enabled, since: b.enabled && !torrentOf[id]?.enabled ? now() : (torrentOf[id]?.since ?? now()) };
+    r.json(torrentView(id));
+});
+
 app.get("/api/users", (q, r) => r.json({ users: U_(q) }));
-app.get("/api/users/stats", (q, r) => r.json({ users: U_(q).map(({ vpn_key, pub_key, ...u }) => u) }));
+// Приоритет в моке: пока на сервере 0 включено деление канала, первый пользователь «фоновый».
+// С меткой «торренты» — тоже фоновый (пока включено деление канала).
+const prioOf = (q: express.Request, ip: string) =>
+    (srv(q) === 0 && shapingOf[0]?.enabled && (ip === "10.9.0.2" || torrentSeenIp(tsid(q), ip)) ? "background" : "normal");
+app.get("/api/users/stats", (q, r) => r.json({ users: U_(q).map(({ vpn_key, pub_key, ...u }) => ({ ...u, priority: prioOf(q, u.ip), torrent: torrentSeenIp(tsid(q), u.ip) })) }));
 app.post("/api/users/reissue", (q, r) => r.json({ total: U_(q).length, reissued: U_(q).length, regenerated: [], backup: "" }));
 app.post("/api/users", (q, r) => {
     const users = U_(q);
@@ -119,6 +235,19 @@ app.patch("/ui/apikeys/:id", (q, r) => {
 });
 app.delete("/ui/apikeys/:id", (q, r) => { const i = apiKeys.findIndex(k => k.id === Number(q.params.id)); if (i >= 0) apiKeys.splice(i, 1); r.json({ success: true }); });
 
+let mockAuditSettings = { clean: false, every_h: 1, max: 10 };
+let mockCleaned: unknown[] = [];
+let mockGhost = true;
+const mockAudit = () => ({ enabled: true, settings: mockAuditSettings, cleaned: mockCleaned, report: { at: Math.floor(Date.now() / 1000) - 600, servers: [
+    { server_id: 0, status: "ok", ghosts_checked: true, foreign: 0, orphans: [], ghosts: mockGhost ? [
+        { pub_key: "Zm9yZ2V0dGluZy16b21iaWUta2V5LTAwMDAwMDAwMDA=", online: true, lastHandshake: Math.floor(Date.now() / 1000) - 30, seen_before: true } ] : [] } ] } });
+app.get("/ui/masterkeys/audit", (_q, r) => r.json(mockAudit()));
+app.post("/ui/masterkeys/audit", (_q, r) => r.json(mockAudit()));
+app.post("/ui/masterkeys/audit/clean", (_q, r) => {
+    if (mockGhost) mockCleaned = [{ at: Math.floor(Date.now() / 1000), server_id: 0, pub_key: "Zm9yZ2V0dGluZy16b21iaWUta2V5LTAwMDAwMDAwMDA=", kind: "ghost", auto: false }, ...mockCleaned];
+    mockGhost = false; r.json(mockAudit());
+});
+app.put("/ui/masterkeys/audit/settings", (q, r) => { mockAuditSettings = { ...mockAuditSettings, ...q.body }; r.json(mockAudit()); });
 app.get("/ui/masterkeys", (_q, r) => r.json({ enabled: true, tls: false, keys: masters.map(mkOut) }));
 app.post("/ui/masterkeys", (q, r) => {
     const limit = q.body.device_limit ?? 3;

awg-ui/monitor.ts

@@ -0,0 +1,195 @@
+// Copyright (c) 2026 Ivan Vasilev
+// This source code is licensed under the MIT license found in the
+// LICENSE file in the root directory of this source tree.
+//
+// Вкладка «Монитор»: встроенный Prometheus и основные графики прямо в панели.
+//   GET  /ui/monitor            — готов ли Prometheus, можно ли поставить его кнопкой, ход установки
+//   POST /ui/monitor/install    — попросить локальный awg-ctrl выполнить `awg-ctrl monitor install` (root)
+//   POST /ui/monitor/remove     — то же для `awg-ctrl monitor remove` (удаление вместе с накопленными данными)
+//   GET  /ui/monitor/overview   — серии для графиков за 1 ч / 6 ч / 24 ч
+// Панель сама пакетов не ставит и в Prometheus лезет только фиксированными запросами (не PromQL от клиента).
+import axios from "axios";
+import { Router, type Request, type Response } from "express";
+
+type Ctrl = (method: string, urlPath: string, body?: unknown) => Promise<{ status: number; data: any }>;
+
+const PROM_URL = process.env.PROM_URL ?? "http://127.0.0.1:9090";
+
+// Шаг подбираем так, чтобы на графике было ~250–360 точек; окно rate — минимум два скрейпа (15 с).
+// Дальше 30 дней не заглядываем: столько Prometheus хранит (RETENTION в cli/src/monitor.ts).
+const RANGES: Record<string, { seconds: number; step: number }> = {
+    "1h":  { seconds: 3600,    step: 15 },
+    "6h":  { seconds: 21600,   step: 60 },
+    "24h": { seconds: 86400,   step: 300 },
+    "7d":  { seconds: 604800,  step: 1800 },
+    "30d": { seconds: 2592000, step: 7200 },
+};
+// Окно rate() — не короче шага: иначе на неделе/месяце точка была бы случайной двухминутной выборкой
+// из двух часов, а не средним за них. Значения «сейчас» при этом считаются отдельно, по окну 2m.
+const RATE_WINDOW = "2m";
+const withWindow = (q: string, w: string) => q.split(`[${RATE_WINDOW}]`).join(`[${w}]`);
+
+type Point  = [number, number];
+type Series = Map<number, { name: string; points: Point[] }>;   // server_id → ряд
+
+// Запросы по серверам. Трафик берём со счётчиков интерфейса (монотонны), а не с сумм по пирам:
+// сумма по пирам падает при удалении пира, и rate() рисовал бы ложный всплеск.
+const QUERIES = {
+    down:      'sum by (server_id, server) (rate(awg_link_transmit_bytes_total[2m])) * 8',
+    up:        'sum by (server_id, server) (rate(awg_link_receive_bytes_total[2m])) * 8',
+    online:    'sum by (server_id, server) (awg_peers_online)',
+    heavy:     'sum by (server_id, server) (awg_shaping_heavy_devices)',
+    drops:     'sum by (server_id, server) (rate(awg_shaping_qdisc_drops_total[2m]))',
+    congested: 'max by (server_id, server) (awg_shaping_congested)',
+    scrape_ok: 'max by (server_id, server) (awg_scrape_ok)',
+    // Загрузка процессора: доля времени не в idle/iowait. Память: MemAvailable, а не MemFree (кэш ядра свободен).
+    cpu: '100 * (1 - sum by (server_id, server) (rate(awg_host_cpu_seconds_total{mode=~"idle|iowait"}[2m])) / sum by (server_id, server) (rate(awg_host_cpu_seconds_total[2m])))',
+    mem: '100 * (1 - sum by (server_id, server) (awg_host_memory_available_bytes) / sum by (server_id, server) (awg_host_memory_total_bytes))',
+    cores:     'max by (server_id, server) (awg_host_cpu_cores)',
+    mem_total: 'max by (server_id, server) (awg_host_memory_total_bytes)',
+} as const;
+type Key = keyof typeof QUERIES;
+
+async function instantQuery(query: string, time: number): Promise<Map<number, number>> {
+    const r = await axios.get(`${PROM_URL}/api/v1/query`, { params: { query, time }, timeout: 8000 });
+    const out = new Map<number, number>();
+    for (const m of (r.data?.data?.result ?? []) as { metric: Record<string, string>; value: [number, string] }[]) {
+        const id = Number(m.metric.server_id), v = Number(m.value[1]);
+        if (Number.isInteger(id) && Number.isFinite(v)) out.set(id, v);
+    }
+    return out;
+}
+
+async function rangeQuery(query: string, start: number, end: number, step: number): Promise<Series> {
+    const r = await axios.get(`${PROM_URL}/api/v1/query_range`, {
+        params: { query, start, end, step }, timeout: 8000,
+    });
+    const out: Series = new Map();
+    for (const m of (r.data?.data?.result ?? []) as { metric: Record<string, string>; values: [number, string][] }[]) {
+        const id = Number(m.metric.server_id);
+        if (!Number.isInteger(id)) continue;
+        out.set(id, {
+            name: m.metric.server ?? String(id),
+            // NaN/Inf из деления на ноль отбрасываем: на графике это дыра, а не нулевая скорость
+            points: m.values.map(([t, v]) => [t, Number(v)] as Point).filter(p => Number.isFinite(p[1])),
+        });
+    }
+    return out;
+}
+
+// Сумма рядов по меткам времени (Prometheus выравнивает точки по шагу, метки совпадают).
+function total(series: Series, how: "sum" | "max" = "sum"): Point[] {
+    const acc = new Map<number, number>();
+    for (const s of series.values()) for (const [t, v] of s.points)
+        acc.set(t, how === "sum" ? (acc.get(t) ?? 0) + v : Math.max(acc.get(t) ?? 0, v));
+    return [...acc.entries()].sort((a, b) => a[0] - b[0]);
+}
+
+const last = (s?: { points: Point[] }): number | null => s && s.points.length ? s.points[s.points.length - 1][1] : null;
+
+export function createMonitor(deps: { ctrlLocal: Ctrl; localEnabled: boolean }) {
+    const router = Router();
+
+    const promReady = async (): Promise<boolean> => {
+        try { return (await axios.get(`${PROM_URL}/-/ready`, { timeout: 1500, validateStatus: () => true })).status === 200; }
+        catch { return false; }
+    };
+
+    // Установка возможна, только если рядом свой awg-ctrl (у панели без собственного VPN его нет —
+    // тогда остаётся команда в терминале) и он достаточно новый, чтобы знать маршрут.
+    type Job = { can: boolean; action: "install" | "remove" | null; running: boolean; exit: number | null; log: string };
+    async function jobState(): Promise<Job> {
+        const none: Job = { can: false, action: null, running: false, exit: null, log: "" };
+        if (!deps.localEnabled) return none;
+        try {
+            const r = await deps.ctrlLocal("GET", "/api/monitor/job");
+            if (r.status !== 200) return none;
+            return { can: true, action: r.data.action ?? null, running: !!r.data.running, exit: r.data.exit ?? null, log: String(r.data.log ?? "") };
+        } catch { return none; }
+    }
+
+    router.get("/", async (_req: Request, res: Response) => {
+        const [ready, job] = await Promise.all([promReady(), jobState()]);
+        res.json({
+            ready,
+            can_install: job.can,
+            // Последняя операция (установка или удаление) и её лог; null — ещё не запускали
+            job: job.can && job.action ? { action: job.action, running: job.running, exit: job.exit, log: job.log } : null,
+            command: "awg-ctrl monitor install",
+        });
+    });
+
+    // Установка и удаление — одно и то же: просим локальный awg-ctrl, он запускает CLI от root.
+    const ask = (action: "install" | "remove") => async (_req: Request, res: Response) => {
+        if (!deps.localEnabled) { res.status(409).json({ error: "У этой панели нет своего VPN-сервера: выполните команду на машине" }); return; }
+        try {
+            const r = await deps.ctrlLocal("POST", `/api/monitor/${action}`);
+            res.status(r.status === 404 ? 501 : r.status).json(
+                r.status === 404 ? { error: "awg-ctrl старой версии не умеет этого: обновите сервер или выполните команду вручную" } : r.data);
+        } catch { res.status(502).json({ error: "awg-ctrl недоступен" }); }
+    };
+    router.post("/install", ask("install"));
+    router.post("/remove",  ask("remove"));
+
+    router.get("/overview", async (req: Request, res: Response) => {
+        const range = RANGES[String(req.query.range ?? "1h")];
+        if (!range) { res.status(400).json({ error: "range: 1h, 6h, 24h, 7d или 30d" }); return; }
+        const end   = Math.floor(Date.now() / 1000);
+        const start = end - range.seconds;
+        try {
+            const keys = Object.keys(QUERIES) as Key[];
+            const window = range.step > 120 ? `${range.step}s` : RATE_WINDOW;
+            const got  = await Promise.all(keys.map(k => rangeQuery(withWindow(QUERIES[k], window), start, end, range.step)));
+            // Окно расширено — «сейчас» с конца ряда было бы средним за шаг; берём мгновенные значения по 2m.
+            const rated: Key[] = ["down", "up", "cpu"];
+            const now   = window === RATE_WINDOW ? null
+                : new Map(await Promise.all(rated.map(async k => [k, await instantQuery(QUERIES[k], end)] as const)));
+            // Вкладка показывает один сервер — тот, что выбран в сервер-баре (?server=<id>).
+            const only = Number.isInteger(Number(req.query.server)) && req.query.server !== undefined ? Number(req.query.server) : null;
+            const s = Object.fromEntries(keys.map((k, i) => [k,
+                only === null ? got[i] : new Map([...got[i]].filter(([id]) => id === only))])) as Record<Key, Series>;
+
+            // Список серверов — из любого ряда, где они есть; «последнее значение» берём с конца окна.
+            const ids = new Set<number>();
+            for (const k of keys) for (const id of s[k].keys()) ids.add(id);
+            // Объём за весь период: increase() по тем же монотонным счётчикам интерфейса (сбросы счётчика он учитывает)
+            const [usedDown, usedUp] = await Promise.all([
+                instantQuery(`sum by (server_id, server) (increase(awg_link_transmit_bytes_total[${range.seconds}s]))`, end),
+                instantQuery(`sum by (server_id, server) (increase(awg_link_receive_bytes_total[${range.seconds}s]))`, end),
+            ]);
+            const cur = (k: Key, id: number) => now?.has(k) ? (now.get(k)!.get(id) ?? null) : last(s[k].get(id));
+            const servers = [...ids].sort((a, b) => a - b).map(id => ({
+                id,
+                name:      (s.scrape_ok.get(id) ?? s.down.get(id) ?? s.online.get(id))?.name ?? String(id),
+                ok:        last(s.scrape_ok.get(id)) === 1,
+                down:      cur("down", id),
+                up:        cur("up", id),
+                online:    last(s.online.get(id)),
+                heavy:     last(s.heavy.get(id)),
+                congested: last(s.congested.get(id)) === 1,
+                cpu:       cur("cpu", id),
+                mem:       last(s.mem.get(id)),
+                cores:     last(s.cores.get(id)),
+                mem_total: last(s.mem_total.get(id)),
+                used_down: usedDown.get(id) ?? null,
+                used_up:   usedUp.get(id) ?? null,
+            }));
+
+
+            res.json({
+                range: req.query.range ?? "1h", step: range.step, from: start, to: end,
+                servers,
+                total: {
+                    down: total(s.down), up: total(s.up), online: total(s.online),
+                    heavy: total(s.heavy), drops: total(s.drops),
+                    cpu: total(s.cpu, "max"), mem: total(s.mem, "max"),
+                },
+            });
+        } catch (e) {
+            // Prometheus стоит, но не ответил: график важнее ошибки, но причину оператору покажем
+            res.status(502).json({ error: axios.isAxiosError(e) ? "Prometheus не отвечает" : (e as Error).message });
+        }
+    });
+
+    return { router };
+}

awg-ui/nodes.ts

@@ -305,9 +305,9 @@ export function createNodes(deps: { uidb: Database.Database; ctrlLocal: Ctrl; ba
 
     const router = Router();
 
-    router.get("/", async (_req: Request, res: Response) => {
-        if (LOCAL) await refreshHealth(0);
-        const nodes: unknown[] = [];
+    // Серверы со всем, что известно без запросов (health — из кэша). Общий вид для GET / и для метрик.
+    const list = () => {
+        const nodes: { id: number; name: string; local: boolean; online: boolean; pending: boolean; last_seen: number | null; version: string | null; health: Health | null }[] = [];
         if (LOCAL) {
             const h = health.get(0) ?? null;
             nodes.push({ id: 0, name: h?.server ?? "VPN", local: true, online: h !== null, pending: false, last_seen: null, version: deps.version || null, health: h });
@@ -318,7 +318,12 @@ export function createNodes(deps: { uidb: Database.Database; ctrlLocal: Ctrl; ba
                 pending: n.pub === null, last_seen: n.last_seen, version: n.version ?? null, health: health.get(n.id) ?? null,
             });
         }
-        res.json({ hub: hubReady(), local: LOCAL, version: deps.version || null, nodes });
+        return nodes;
+    };
+
+    router.get("/", async (_req: Request, res: Response) => {
+        if (LOCAL) await refreshHealth(0);
+        res.json({ hub: hubReady(), local: LOCAL, version: deps.version || null, nodes: list() });
     });
 
     router.post("/", (req: Request, res: Response) => {
@@ -379,5 +384,5 @@ export function createNodes(deps: { uidb: Database.Database; ctrlLocal: Ctrl; ba
         res.json({ success: true, id });
     });
 
-    return { router, ctrlFor, exists, isOnline, ids, onOnline, beforeDelete, afterDelete, defaultId, start };
+    return { router, ctrlFor, exists, isOnline, ids, list, onOnline, beforeDelete, afterDelete, defaultId, start };
 }

awg-ui/package.json

@@ -1,6 +1,6 @@
 {
   "name": "awg-ui",
-  "version": "0.3.4",
+  "version": "0.4.3",
   "private": true,
   "scripts": {
     "dev": "vite",

awg-ui/server.ts

@@ -9,6 +9,8 @@ import axios    from "axios";
 import Database from "better-sqlite3";
 import { createSub } from "./sub";
 import { createNodes } from "./nodes";
+import { createMetrics } from "./metrics";
+import { createMonitor } from "./monitor";
 
 const app  = express();
 const PORT = Number(process.env.PORT) || 8080;
@@ -362,6 +364,15 @@ app.use("/ui/nodes", requireAuth, nodes.router);
 const sub = createSub({ uidb, servers: nodes, baseDir: __dirname });
 app.use("/ui/masterkeys", requireAuth, sub.masterKeys);
 app.use("/ui/devices",    requireAuth, sub.devices);
+
+// Prometheus: /metrics за отдельным токеном «только метрики» (не JWT и не ключ API), токеном
+// управляет панель. Регистрируется до SPA-фолбэка внизу, иначе его перехватит `*`.
+const metrics = createMetrics({ uidb, version: VERSION, servers: nodes });
+app.use("/ui/metrics-token", requireAuth, metrics.router);
+app.get("/metrics", metrics.requireToken, metrics.handler);
+// Монитор: встроенный Prometheus и графики во вкладке. Ставит его не панель, а awg-ctrl от root.
+const monitor = createMonitor({ ctrlLocal: ctrl, localEnabled: (process.env.LOCAL_NODE ?? "on").toLowerCase() !== "off" });
+app.use("/ui/monitor", requireAuth, monitor.router);
 // Мастер-ключи во внешнем API — в пределах набора серверов API-ключа. ext уже смонтирован
 // на /api/v1 до JWT-прокси, роуты в нём можно добавлять и позже.
 ext.use("/masterkeys", sub.apiRouter(req => (req as ExtRequest).servers ?? []));

awg-ui/src/App.css

@@ -332,6 +332,8 @@ body {
     cursor: default;
     user-select: none;
 }
+.nav-group { display: flex; flex-direction: column; gap: 2px; margin-bottom: 8px; }
+.nav-group-title { padding: 8px 12px 4px; font-size: 12px; color: var(--neutral-text); user-select: none; }
 .nav-item--active {
     background: var(--primary-container);
     color: var(--on-primary-container);
@@ -415,6 +417,7 @@ body {
 }
 .node-modal {
     width: 100%; max-width: 520px;
+    max-height: 100%; overflow-y: auto;
     background: var(--surface-bright);
     border: 1px solid var(--outline-variant);
     border-radius: var(--r-card);
@@ -433,6 +436,22 @@ body {
     user-select: all;
 }
 .node-modal-actions { display: flex; gap: 8px; justify-content: flex-end; flex-wrap: wrap; }
+
+/* Настройки сервера: деление канала */
+.ss-setting { display: flex; align-items: center; justify-content: space-between; gap: 12px; min-height: 44px; }
+.ss-setting-text { display: flex; flex-direction: column; gap: 2px; min-width: 0; }
+.ss-setting-name { font-size: 14px; color: var(--on-surface); }
+.ss-setting input[type="checkbox"] { width: 20px; height: 20px; flex: none; accent-color: var(--primary); }
+.ss-grid { display: grid; grid-template-columns: 1fr 1fr; gap: 12px; }
+.ss-field { display: flex; flex-direction: column; gap: 6px; min-width: 0; }
+.ss-status { display: flex; flex-wrap: wrap; align-items: center; gap: 8px 12px; background: var(--surface-container); border-radius: var(--r-table); padding: 12px; }
+.ss-mono { font-family: var(--mono); font-size: 12px; color: var(--neutral-text); word-break: break-all; }
+.ss-section { margin: 4px 0 0; font-size: 14px; font-weight: 500; color: var(--on-surface); }
+.ss-divider { border: 0; border-top: 1px solid var(--outline-variant); margin: 4px 0; }
+.ss-seen { display: flex; flex-wrap: wrap; gap: 6px; }
+/* Тёплый чип «внимание»: канал занят, фоновый приоритет */
+.chip--warm { background: var(--tertiary-container); color: var(--on-tertiary-container); }
+.chip--warm .chip-dot { background: var(--on-tertiary-container); }
 .server-card-info {
     display: flex;
     flex-direction: column;
@@ -766,3 +785,14 @@ tbody td:last-child  { padding-right: 20px; }
 .server-pick-name { font-weight: 500; }
 .server-pick-ip, .server-pick-gen { font-size: 12px; color: var(--neutral-text); }
 .server-pick-ip { font-family: var(--mono); margin-left: auto; }
+
+/* Короткий идентификатор под именем (UUID мастер-ключа, ID устройства):
+   первые символы моноширинным, полностью — в подсказке, по клику копируется. */
+.name-stack { display: inline-flex; flex-direction: column; line-height: 1.25; vertical-align: middle; }
+.copy-id {
+    align-self: flex-start;
+    background: none; border: 0; padding: 0; margin: 0; cursor: pointer;
+    font-family: var(--mono); font-size: 11px; font-weight: 400; color: var(--neutral-text);
+}
+.copy-id:hover { color: var(--primary); }
+.copy-id:focus-visible { outline: 2px solid var(--primary); outline-offset: 2px; border-radius: 4px; }

awg-ui/src/App.tsx

@@ -11,7 +11,8 @@ import {
 import { IcoMenu, IcoLogout, IcoSun, IcoMoon, IcoRefresh } from './components/icons';
 import ServerBar from './components/ServerBar';
 import AddServerModal from './components/AddServerModal';
-import { TABS } from './tabs';
+import ServerSettingsModal from './components/ServerSettingsModal';
+import { TABS, TABS_BY_GROUP } from './tabs';
 
 // Оболочка приложения: логин, тема, drawer/сайдбар, общая сессия (token,
 // список серверов и выбранный сервер, снэкбар) и переключение вкладок. Контент каждой вкладки приходит
@@ -26,6 +27,7 @@ export default function App() {
     const [panelVersion, setPanelVersion] = useState<string | null>(null);
     const [serverId, setServerIdState] = useState<number | null>(null);
     const [modal, setModal]           = useState<{ node?: NodeInfo } | null>(null);
+    const [settingsFor, setSettingsFor] = useState<NodeInfo | null>(null);
     const [msg, setMsg]               = useState('');
     const [drawerOpen, setDrawerOpen] = useState(false);
     const [activeTab, setActiveTab]   = useState(TABS[0].id);
@@ -147,6 +149,24 @@ export default function App() {
         if (touchStartX.current - touchCurrentX.current > 40) setDrawerOpen(false);
     }, []);
 
+    // Токен протух (24 ч) или отозван, пока панель открыта: запросы вкладок падали с 401, а экран
+    // оставался прежним. Выходим только по 401 самой панели («Unauthorized» — её JWT не принят):
+    // 401 от awg-ctrl ноды (внутренняя авторизация) пересылается как есть и сессию не рвёт.
+    useEffect(() => {
+        const id = axios.interceptors.response.use(undefined, e => {
+            if (axios.isAxiosError(e) && e.response?.status === 401 && e.response.data?.error === 'Unauthorized') {
+                localStorage.removeItem(TOKEN_KEY);
+                setToken('');
+                setNodes([]);
+                setServerId(null);
+                setServerIdState(null);
+                showMsg('Сессия истекла — войдите снова');
+            }
+            return Promise.reject(e);
+        });
+        return () => axios.interceptors.response.eject(id);
+    }, [showMsg]);
+
     // Восстановить сессию из сохранённого токена
     useEffect(() => {
         const saved = localStorage.getItem(TOKEN_KEY);
@@ -288,14 +308,19 @@ export default function App() {
                                 </span>
                             </div>
                             <hr className="drawer-divider" />
-                            {TABS.map(t => (
-                                <div
-                                    key={t.id}
-                                    className={`nav-item${t.id === activeTab ? ' nav-item--active' : ''}`}
-                                    onClick={() => { setActiveTab(t.id); setDrawerOpen(false); }}
-                                >
-                                    <t.Icon /> {t.label}
-                                </div>
+                            {TABS_BY_GROUP.map(g => (
+                                <nav key={g.id} className="nav-group" aria-label={g.label}>
+                                    <span className="nav-group-title">{g.label}</span>
+                                    {g.tabs.map(t => (
+                                        <div
+                                            key={t.id}
+                                            className={`nav-item${t.id === activeTab ? ' nav-item--active' : ''}`}
+                                            onClick={() => { setActiveTab(t.id); setDrawerOpen(false); }}
+                                        >
+                                            <t.Icon /> {t.label}
+                                        </div>
+                                    ))}
+                                </nav>
                             ))}
 
                             <div className="sidebar-spacer" />
@@ -318,6 +343,8 @@ export default function App() {
                                     onAdd={() => setModal({})}
                                     onJoin={n => setModal({ node: n })}
                                     onDelete={deleteNode}
+                                    // Сначала выбираем сервер: запросы модалки идут с X-Server-Id выбранного
+                                    onSettings={n => { pickServer(n.id); setSettingsFor(n); }}
                                     onRestartAwg={restartAwg}
                                     restarting={restarting}
                                     showRestart={showRestart}
@@ -346,6 +373,15 @@ export default function App() {
                 />
             )}
 
+            {settingsFor && (
+                <ServerSettingsModal
+                    token={token}
+                    node={settingsFor}
+                    onClose={() => setSettingsFor(null)}
+                    showMsg={showMsg}
+                />
+            )}
+
             {msg && <div className="snack">{msg}</div>}
         </div>
     );

awg-ui/src/components/LineChart.tsx

@@ -0,0 +1,194 @@
+// Copyright (c) 2026 Ivan Vasilev
+// This source code is licensed under the MIT license found in the
+// LICENSE file in the root directory of this source tree.
+import { useEffect, useMemo, useRef, useState } from 'react';
+
+// Линейный график для вкладки «Монитор». Одна ось, линия 2 px, конечная точка с кольцом цвета поверхности,
+// перекрестие с подсказкой по всем рядам, легенда при ≥ 2 рядах, табличный вид и управление стрелками.
+// Цвета рядов — токены темы (--series-N в monitor.css), подписи и значения — всегда цветом текста.
+export interface ChartSeries { id: string; name: string; color: string; points: [number, number][] }
+
+const M = { left: 46, right: 14, top: 10, bottom: 24 };
+
+// Шкала оси: круглый шаг (1, 2, 2.5, 5 × 10ⁿ) и 3–5 интервалов, чтобы подписи были 0 / 50 / 100 / 150, а не 0 / 63 / 125.
+function niceScale(max: number): { top: number; ticks: number[] } {
+    if (!(max > 0)) return { top: 1, ticks: [0, 1] };
+    const raw  = max / 4;
+    const p    = Math.pow(10, Math.floor(Math.log10(raw)));
+    const step = ([1, 2, 2.5, 5, 10].map(f => f * p).find(s => s >= raw)) ?? 10 * p;
+    const n    = Math.max(1, Math.ceil(max / step - 1e-9));
+    return { top: step * n, ticks: Array.from({ length: n + 1 }, (_, i) => step * i) };
+}
+
+const timeLabel = (t: number, span: number) => {
+    const d = new Date(t * 1000);
+    const hm = d.toLocaleTimeString('ru-RU', { hour: '2-digit', minute: '2-digit' });
+    return span > 86400 * 1.5 ? `${d.toLocaleDateString('ru-RU', { day: '2-digit', month: '2-digit' })} ${hm}` : hm;
+};
+
+export default function LineChart({ title, series, from, to, step, format, formatAxis, max, dim = false }: {
+    title:        string;
+    series:       ChartSeries[];
+    from:         number;
+    to:           number;
+    step:         number;                       // шаг данных, с: разрыв длиннее трёх шагов рвёт линию, а не рисует мост
+    format:       (v: number) => string;        // значение в подсказке и таблице
+    formatAxis?:  (v: number) => string;        // компактная подпись оси
+    max?:         number;                       // фиксированный верх оси (проценты — 100); без него подбирается по данным
+    dim?:         boolean;                      // идёт перезагрузка: держим прежний кадр бледнее
+}) {
+    const wrap = useRef<HTMLDivElement>(null);     // содержимое карточки без её padding: от него зависит ширина svg
+    const [w, setW] = useState(640);
+    const [hover, setHover] = useState<number | null>(null);     // индекс по оси времени
+    const [table, setTable] = useState(false);
+    const H = 200;
+
+    useEffect(() => {
+        const el = wrap.current;
+        if (!el) return;
+        const ro = new ResizeObserver(() => setW(Math.max(260, el.clientWidth)));
+        ro.observe(el); setW(Math.max(260, el.clientWidth));
+        return () => ro.disconnect();
+    }, []);
+
+    // Общая ось времени: метки первого непустого ряда (Prometheus выравнивает точки по шагу).
+    const times = useMemo(() => {
+        const set = new Set<number>();
+        for (const s of series) for (const p of s.points) set.add(p[0]);
+        return [...set].sort((a, b) => a - b);
+    }, [series]);
+    const byTime = useMemo(() => series.map(s => new Map(s.points)), [series]);
+
+    const empty = times.length === 0;
+    const { top: yMax, ticks: yTicks } = max !== undefined
+        ? { top: max, ticks: [0, 1, 2, 3, 4].map(i => (max / 4) * i) }
+        : niceScale(Math.max(0, ...series.flatMap(s => s.points.map(p => p[1]))) * 1.04);
+    const x = (t: number) => M.left + ((t - from) / Math.max(1, to - from)) * (w - M.left - M.right);
+    const y = (v: number) => H - M.bottom - (v / yMax) * (H - M.top - M.bottom);
+
+    const path = (pts: [number, number][]) => {
+        let d = '', prev: number | null = null;
+        for (const [t, v] of pts) {
+            d += `${prev !== null && t - prev <= step * 3 ? 'L' : 'M'}${x(t).toFixed(1)},${y(v).toFixed(1)}`;
+            prev = t;
+        }
+        return d;
+    };
+
+    const span   = to - from;
+    const xTicks = [0, 1, 2, 3, 4].map(i => from + (span / 4) * i);
+    const axis   = formatAxis ?? format;
+
+    const onMove = (e: React.PointerEvent<SVGRectElement>) => {
+        if (!times.length) return;
+        const r  = e.currentTarget.getBoundingClientRect();
+        const t  = from + ((e.clientX - r.left) / Math.max(1, r.width)) * span;
+        let best = 0;
+        for (let i = 1; i < times.length; i++) if (Math.abs(times[i] - t) < Math.abs(times[best] - t)) best = i;
+        setHover(best);
+    };
+    const onKey = (e: React.KeyboardEvent) => {
+        if (!times.length) return;
+        if (e.key === 'ArrowLeft')  { e.preventDefault(); setHover(h => Math.max(0, (h ?? times.length) - 1)); }
+        if (e.key === 'ArrowRight') { e.preventDefault(); setHover(h => Math.min(times.length - 1, (h ?? -1) + 1)); }
+        if (e.key === 'Escape')     setHover(null);
+    };
+
+    const ht = hover !== null ? times[hover] : null;
+    // Подсказка не вылезает за правый край: правее середины открывается влево от перекрестия
+    const flip = ht !== null && x(ht) > w * 0.55;
+
+    // Табличный вид — те же числа без наведения: ~12 равномерно выбранных строк, последняя — самая свежая
+    const rows = useMemo(() => {
+        if (!times.length) return [] as number[];
+        const n = Math.min(12, times.length);
+        return Array.from({ length: n }, (_, i) => times[Math.round(((times.length - 1) * (i + 1)) / n)]).reverse();
+    }, [times]);
+
+    return (
+        <figure className={`mon-chart${dim ? ' mon-chart--dim' : ''}`}>
+            <figcaption className="mon-chart-head">
+                <span className="mon-chart-title">{title}</span>
+                {series.length >= 2 && (
+                    <span className="mon-legend">
+                        {series.map(s => (
+                            <span className="mon-legend-item" key={s.id}>
+                                <i className="mon-key" style={{ background: s.color }} aria-hidden="true" />{s.name}
+                            </span>
+                        ))}
+                    </span>
+                )}
+                <button type="button" className="mon-chart-toggle" aria-pressed={table} onClick={() => setTable(t => !t)}>
+                    {table ? 'График' : 'Таблица'}
+                </button>
+            </figcaption>
+
+            <div ref={wrap}>
+            {table ? (
+                <div className="mon-table-wrap">
+                    <table className="mon-table">
+                        <thead><tr><th>Время</th>{series.map(s => <th key={s.id}>{s.name}</th>)}</tr></thead>
+                        <tbody>
+                            {rows.length === 0 ? <tr><td colSpan={series.length + 1}>Нет данных</td></tr> : rows.map(t => (
+                                <tr key={t}>
+                                    <td>{timeLabel(t, span)}</td>
+                                    {series.map((s, i) => <td key={s.id}>{byTime[i].has(t) ? format(byTime[i].get(t)!) : '—'}</td>)}
+                                </tr>
+                            ))}
+                        </tbody>
+                    </table>
+                </div>
+            ) : (
+                <div className="mon-plot">
+                    <svg width={w} height={H} role="img" tabIndex={0} aria-label={`${title}. Стрелки влево и вправо — значения по времени.`}
+                        onKeyDown={onKey} onBlur={() => setHover(null)}>
+                        {yTicks.map((v, i) => (
+                            <g key={i}>
+                                <line className="mon-grid" x1={M.left} x2={w - M.right} y1={y(v)} y2={y(v)} />
+                                <text className="mon-tick" x={M.left - 8} y={y(v) + 4} textAnchor="end">{axis(v)}</text>
+                            </g>
+                        ))}
+                        {xTicks.map((t, i) => (
+                            <text key={i} className="mon-tick" x={x(t)} y={H - 6} textAnchor={i === 0 ? 'start' : i === 4 ? 'end' : 'middle'}>
+                                {timeLabel(t, span)}
+                            </text>
+                        ))}
+                        {!empty && series.map(s => (
+                            <path key={s.id} d={path(s.points)} fill="none" style={{ stroke: s.color }} strokeWidth={2} strokeLinejoin="round" strokeLinecap="round" />
+                        ))}
+                        {/* конечная точка: r 4 + кольцо цвета поверхности, чтобы читалась поверх линий */}
+                        {!empty && series.map(s => s.points.length > 0 && (
+                            <circle key={s.id} cx={x(s.points[s.points.length - 1][0])} cy={y(s.points[s.points.length - 1][1])}
+                                r={4} style={{ fill: s.color }} className="mon-end" />
+                        ))}
+                        {ht !== null && (
+                            <g>
+                                <line className="mon-cross" x1={x(ht)} x2={x(ht)} y1={M.top} y2={H - M.bottom} />
+                                {series.map((s, i) => byTime[i].has(ht) && (
+                                    <circle key={s.id} cx={x(ht)} cy={y(byTime[i].get(ht)!)} r={4} style={{ fill: s.color }} className="mon-end" />
+                                ))}
+                            </g>
+                        )}
+                        {/* зона наведения шире линии: указатель ищет момент времени, а не 2-пиксельную линию */}
+                        <rect x={M.left} y={M.top} width={Math.max(0, w - M.left - M.right)} height={H - M.top - M.bottom}
+                            fill="transparent" onPointerMove={onMove} onPointerLeave={() => setHover(null)} />
+                    </svg>
+                    {empty && <p className="mon-empty">Данные появятся через минуту-две после запуска Prometheus</p>}
+                    {ht !== null && (
+                        <div className="mon-tip" style={{ left: flip ? undefined : x(ht) + 12, right: flip ? w - x(ht) + 12 : undefined, top: M.top }} role="status">
+                            <span className="mon-tip-time">{timeLabel(ht, span)}</span>
+                            {series.map((s, i) => (
+                                <span className="mon-tip-row" key={s.id}>
+                                    <i className="mon-key" style={{ background: s.color }} aria-hidden="true" />
+                                    <b>{byTime[i].has(ht) ? format(byTime[i].get(ht)!) : '—'}</b>
+                                    <span>{s.name}</span>
+                                </span>
+                            ))}
+                        </div>
+                    )}
+                </div>
+            )}
+            </div>
+        </figure>
+    );
+}

awg-ui/src/components/PriorityChip.tsx

@@ -0,0 +1,28 @@
+// Copyright (c) 2026 Ivan Vasilev
+// This source code is licensed under the MIT license found in the
+// LICENSE file in the root directory of this source tree.
+import type { Priority } from '../lib/shared';
+
+// Текущая приоритетность ключа/устройства. «Фоновый» — только пока канал занят, а устройство давно
+// качает заметно больше своей доли: оно уступает остальным, но свободный канал занимает по-прежнему.
+// Когда деление канала выключено или канал свободен, у всех «обычный». Без поля (awg-ctrl старше
+// деления канала) чип не показываем: «обычный» там было бы выдумкой. С меткой «торренты» устройство
+// фоновое независимо от загрузки канала — подсказка говорит об этом.
+export default function PriorityChip({ priority, torrent }: { priority?: Priority; torrent?: boolean }) {
+    if (!priority) return null;
+    const bg = priority === 'background';
+    return (
+        <span
+            className="tip-wrap"
+            data-tip={!bg
+                ? 'Обычный приоритет: канал делится поровну'
+                : torrent
+                    ? 'Пытается качать торренты — пока висит метка, устройство уступает остальным'
+                    : 'Канал занят, а это устройство давно качает больше своей доли — пока оно уступает остальным'}
+        >
+            <span className={`chip ${bg ? 'chip--warm' : 'chip--offline'}`}>
+                <span className="chip-dot" />{bg ? 'фоновый' : 'обычный'}
+            </span>
+        </span>
+    );
+}

awg-ui/src/components/ServerBar.tsx

@@ -2,7 +2,7 @@
 // This source code is licensed under the MIT license found in the
 // LICENSE file in the root directory of this source tree.
 import { type NodeInfo, genLabel, cmpVersion } from '../lib/shared';
-import { IcoRefresh, IcoPlus, IcoTrash, IcoCopy } from './icons';
+import { IcoRefresh, IcoPlus, IcoTrash, IcoCopy, IcoSettings } from './icons';
 
 // Сервер-бар: карточки серверов (core-локальный и ноды) + «Добавить сервер» и
 // (на мобильной) перезапуск AWG под ними. Общий для вкладок — показывает
@@ -29,7 +29,7 @@ function versionChip(n: NodeInfo, panel: string | null) {
 }
 
 export default function ServerBar({
-    nodes, serverId, hubEnabled, panelVersion, onSelect, onAdd, onJoin, onDelete,
+    nodes, serverId, hubEnabled, panelVersion, onSelect, onAdd, onJoin, onDelete, onSettings,
     onRestartAwg, restarting, showRestart = true,
 }: {
     nodes: NodeInfo[];
@@ -40,6 +40,7 @@ export default function ServerBar({
     onAdd: () => void;
     onJoin: (n: NodeInfo) => void;
     onDelete: (n: NodeInfo) => void;
+    onSettings: (n: NodeInfo) => void;
     onRestartAwg: () => void;
     restarting: boolean;
     showRestart?: boolean;
@@ -103,6 +104,16 @@ export default function ServerBar({
                                 <IcoCopy />
                             </button>
                         )}
+                        {/* Настройки сервера: у ноды, которая ещё не подключалась, настраивать нечего */}
+                        {!n.pending && n.online && (
+                            <button
+                                className="btn-icon btn-icon--neutral"
+                                aria-label={`Настройки сервера ${n.name}`}
+                                onClick={e => { e.stopPropagation(); onSettings(n); }}
+                            >
+                                <IcoSettings />
+                            </button>
+                        )}
                         {!n.local && (
                             <button
                                 className="btn-icon btn-icon--danger"

awg-ui/src/components/ServerSettingsModal.tsx

@@ -0,0 +1,237 @@
+// Copyright (c) 2026 Ivan Vasilev
+// This source code is licensed under the MIT license found in the
+// LICENSE file in the root directory of this source tree.
+import { useEffect, useState } from 'react';
+import axios from 'axios';
+import { apiFetch, type NodeInfo, type ShapingStatus, type TorrentStatus } from '../lib/shared';
+
+// Настройки сервера: деление канала между устройствами (CAKE) и блокировка BitTorrent. Сами
+// настройки живут в awg-ctrl этого сервера — запрос идёт обычным прокси с X-Server-Id (App выбирает сервер
+// до открытия модалки), так что ядро и ноды настраиваются одинаково.
+export default function ServerSettingsModal({ token, node, onClose, showMsg }: {
+    token:   string;
+    node:    NodeInfo;
+    onClose: () => void;
+    showMsg: (text: string) => void;
+}) {
+    const [st, setSt]           = useState<ShapingStatus | null>(null);
+    const [enabled, setEnabled] = useState(false);
+    const [auto, setAuto]       = useState(true);
+    const [down, setDown]       = useState('');
+    const [up, setUp]           = useState('');
+    const [busy, setBusy]       = useState(false);
+    const [error, setError]     = useState('');
+    const [unsupported, setUnsupported] = useState(false);
+    const [tst, setTst]           = useState<TorrentStatus | null>(null);
+    const [tEnabled, setTEnabled] = useState(false);
+    const [tUnsupported, setTUnsupported] = useState(false);
+
+    const fill = (s: ShapingStatus) => {
+        setSt(s);
+        setEnabled(s.settings.enabled); setAuto(s.settings.auto);
+        setDown(s.settings.downMbit ? String(s.settings.downMbit) : '');
+        setUp(s.settings.upMbit ? String(s.settings.upMbit) : '');
+    };
+
+    const errText = (e: unknown, fallback: string) =>
+        axios.isAxiosError(e) ? e.response?.data?.error ?? fallback : fallback;
+
+    const fillTorrent = (s: TorrentStatus) => { setTst(s); setTEnabled(s.settings.enabled); };
+
+    useEffect(() => {
+        let alive = true;
+        apiFetch('GET', '/api/torrent', token)
+            .then(s => { if (alive) fillTorrent(s as TorrentStatus); })
+            .catch(e => {
+                if (!alive) return;
+                if (axios.isAxiosError(e) && e.response?.status === 404) setTUnsupported(true);
+                else setError(errText(e, 'Не удалось загрузить настройки'));
+            });
+        return () => { alive = false; };
+    }, [token]);
+
+    useEffect(() => {
+        let alive = true;
+        apiFetch('GET', '/api/shaping', token)
+            .then(s => { if (alive) fill(s as ShapingStatus); })
+            .catch(e => {
+                if (!alive) return;
+                // Старый awg-ctrl не знает этот маршрут — его надо обновить, а не «починить» здесь.
+                if (axios.isAxiosError(e) && e.response?.status === 404) setUnsupported(true);
+                else setError(errText(e, 'Не удалось загрузить настройки'));
+            });
+        return () => { alive = false; };
+    }, [token]);
+
+    useEffect(() => {
+        const h = (e: KeyboardEvent) => { if (e.key === 'Escape') onClose(); };
+        document.addEventListener('keydown', h);
+        return () => document.removeEventListener('keydown', h);
+    }, [onClose]);
+
+    const downN = Number(down), upN = Number(up);
+    const valid = !enabled || (Number.isInteger(downN) && downN >= 1 && Number.isInteger(upN) && upN >= 1);
+
+    // Отправляем только изменённое: лишний PUT /api/shaping заново ставил бы tc на интерфейс.
+    const shapingDirty = !!st && (enabled !== st.settings.enabled || auto !== st.settings.auto
+        || (Number(down) || 0) !== st.settings.downMbit || (Number(up) || 0) !== st.settings.upMbit);
+    const torrentDirty = !!tst && tEnabled !== tst.settings.enabled;
+
+    const save = async () => {
+        setBusy(true); setError('');
+        const done: string[] = [];
+        try {
+            if (shapingDirty) {
+                const s = await apiFetch('PUT', '/api/shaping', token, {
+                    enabled, auto, downMbit: Number(down) || 0, upMbit: Number(up) || 0,
+                });
+                fill(s as ShapingStatus);
+                done.push(enabled ? 'деление канала включено' : 'деление канала выключено');
+            }
+            if (torrentDirty) {
+                const s = await apiFetch('PUT', '/api/torrent', token, { enabled: tEnabled });
+                fillTorrent(s as TorrentStatus);
+                done.push(tEnabled ? 'торренты блокируются' : 'блокировка торрентов выключена');
+            }
+            if (done.length) showMsg(done.join(', ').replace(/^./, c => c.toUpperCase()));
+        } catch (e) { setError(errText(e, 'Не удалось сохранить')); }
+        finally { setBusy(false); }
+    };
+
+    return (
+        <div className="node-scrim" onClick={onClose}>
+            <div className="node-modal" role="dialog" aria-modal="true" aria-label="Настройки сервера" onClick={e => e.stopPropagation()}>
+                <h3 className="node-modal-title">Настройки сервера: {node.name}</h3>
+                <h4 className="ss-section">Деление канала</h4>
+
+                {unsupported ? (
+                    <p className="node-modal-hint">
+                        Этот сервер не поддерживает деление канала: обновите его (install.sh → «Обновить»).
+                    </p>
+                ) : (
+                    <>
+                        <p className="node-modal-hint">
+                            Канал делится поровну между устройствами, но не простаивает: кто берёт мало, получает всё
+                            нужное, остальное достаётся тем, кто качает много. Звонки и игры не ждут за чужими закачками.
+                        </p>
+
+                        <label className="ss-setting">
+                            <span className="ss-setting-text">
+                                <span className="ss-setting-name">Честное деление между устройствами</span>
+                            </span>
+                            <input type="checkbox" checked={enabled} disabled={!st || busy} onChange={e => setEnabled(e.target.checked)} />
+                        </label>
+
+                        <div className="ss-grid">
+                            <label className="ss-field">
+                                <span className="ss-setting-name">Загрузка, Мбит/с</span>
+                                <input className="field" type="number" inputMode="numeric" min={1} max={100000}
+                                    value={down} disabled={!st || busy} onChange={e => setDown(e.target.value)} />
+                            </label>
+                            <label className="ss-field">
+                                <span className="ss-setting-name">Отдача, Мбит/с</span>
+                                <input className="field" type="number" inputMode="numeric" min={1} max={100000}
+                                    value={up} disabled={!st || busy} onChange={e => setUp(e.target.value)} />
+                            </label>
+                        </div>
+                        <p className="node-modal-hint">
+                            Укажите около 90–95% реального канала сервера. Если задать больше, очередь копится у провайдера
+                            и деление перестаёт работать.
+                        </p>
+
+                        <label className="ss-setting">
+                            <span className="ss-setting-text">
+                                <span className="ss-setting-name">Снижать приоритет тяжёлых</span>
+                                <span className="node-modal-hint">
+                                    Когда канал занят, устройства, которые долго качают заметно больше своей доли, временно
+                                    уходят в фоновый класс. Работает на загрузку; свободный канал они по-прежнему занимают.
+                                </span>
+                            </span>
+                            <input type="checkbox" checked={auto} disabled={!st || busy || !enabled} onChange={e => setAuto(e.target.checked)} />
+                        </label>
+
+                        {st?.settings.enabled && (
+                            <div className="ss-status">
+                                <span className={`chip ${st.active ? (st.congested ? 'chip--warm' : 'chip--online') : 'chip--offline'}`}>
+                                    <span className="chip-dot" />
+                                    {!st.active ? 'не применено' : st.congested ? 'канал занят' : 'канал свободен'}
+                                </span>
+                                <span className="ss-mono">
+                                    ↓ {st.rateDown} · ↑ {st.rateUp} Мбит/с · устройств {st.devices}
+                                </span>
+                                {st.heavy.length > 0 && (
+                                    <span className="ss-mono">в фоне: {st.heavy.join(', ')}</span>
+                                )}
+                            </div>
+                        )}
+                    </>
+                )}
+
+                <hr className="ss-divider" />
+                <h4 className="ss-section">Торренты</h4>
+                {tUnsupported ? (
+                    <p className="node-modal-hint">
+                        Этот сервер не умеет блокировать торренты: обновите его (install.sh → «Обновить»).
+                    </p>
+                ) : (
+                    <>
+                        <label className="ss-setting">
+                            <span className="ss-setting-text">
+                                <span className="ss-setting-name">Блокировать BitTorrent</span>
+                                <span className="node-modal-hint">
+                                    Режет поиск пиров (DHT), трекеры и начало торрент-соединений — как блокировка в 3x-ui.
+                                    Клиент с шифрованием и HTTPS-трекерами может частично её обойти, но без DHT и открытых
+                                    трекеров большинство торрентов не стартуют. Остальной трафик не режется.
+                                </span>
+                                <span className="node-modal-hint">
+                                    {enabled
+                                        ? 'Кто пытается качать, на 10 минут после последней попытки уходит в фоновый приоритет: уступает остальным, когда канал занят.'
+                                        : 'Включите деление канала — тогда кто пытается качать, на 10 минут уйдёт ещё и в фоновый приоритет.'}
+                                </span>
+                            </span>
+                            <input type="checkbox" checked={tEnabled} disabled={!tst || busy} onChange={e => setTEnabled(e.target.checked)} />
+                        </label>
+
+                        {tst?.settings.enabled && (
+                            <div className="ss-status">
+                                <span className={`chip ${tst.active ? 'chip--online' : 'chip--offline'}`}>
+                                    <span className="chip-dot" />{tst.active ? 'работает' : 'не применено'}
+                                </span>
+                                <span className="ss-mono">заблокировано попыток: {tst.hits.toLocaleString('ru-RU')}</span>
+                                {tst.active && !tst.tcp && (
+                                    <span className="node-modal-hint">
+                                        TCP не проверяется: на сервере старый nftables. DHT, трекеры и uTP блокируются.
+                                    </span>
+                                )}
+                                {tst.error && <span className="node-modal-hint">{tst.error}</span>}
+                                {tst.seen.length > 0 && (
+                                    <>
+                                        <span className="node-modal-hint">Пытались качать за последние 10 минут:</span>
+                                        <span className="ss-seen">
+                                            {tst.seen.map(p => (
+                                                <span key={p.ip} className="chip chip--error">
+                                                    <span className="chip-dot" />{p.name ? `${p.name} · ${p.ip}` : p.ip}
+                                                </span>
+                                            ))}
+                                        </span>
+                                    </>
+                                )}
+                            </div>
+                        )}
+                    </>
+                )}
+
+                {error && <p className="login-error">{error}</p>}
+
+                <div className="node-modal-actions">
+                    {!(unsupported && tUnsupported) && (
+                        <button className="btn btn--primary" onClick={save} disabled={busy || !valid || !(shapingDirty || torrentDirty)}>
+                            Сохранить
+                        </button>
+                    )}
+                    <button className="btn btn--outline" onClick={onClose}>Закрыть</button>
+                </div>
+            </div>
+        </div>
+    );
+}

awg-ui/src/components/TorrentChip.tsx

@@ -0,0 +1,14 @@
+// Copyright (c) 2026 Ivan Vasilev
+// This source code is licensed under the MIT license found in the
+// LICENSE file in the root directory of this source tree.
+
+// Пометка «торренты»: устройство за последние 10 минут пыталось открыть торрент-соединение, и оно
+// было заблокировано. Без флага (блокировка выключена или awg-ctrl старше) чип не показываем.
+export default function TorrentChip({ torrent }: { torrent?: boolean }) {
+    if (!torrent) return null;
+    return (
+        <span className="tip-wrap" data-tip="За последние 10 минут пыталось качать торренты: соединения заблокированы, а при делении канала устройство в фоновом приоритете">
+            <span className="chip chip--error"><span className="chip-dot" />торренты</span>
+        </span>
+    );
+}

awg-ui/src/components/icons.tsx

@@ -90,7 +90,21 @@ export const IcoMoon = () => (
 
 // Карта «имя → иконка» для вкладок: metadata.json хранит имя строкой, реестр
 // (tabs/index.ts) резолвит его сюда. Новой вкладке — добавь сюда её иконку.
+export const IcoShield = () => (
+    <svg width="16" height="16" viewBox="0 0 24 24" fill="none" stroke="currentColor" strokeWidth="2" strokeLinecap="round" strokeLinejoin="round">
+        <path d="M12 3 4 6v6c0 4.5 3.4 8.3 8 9 4.6-.7 8-4.5 8-9V6l-8-3z"/><path d="m9 12 2 2 4-4"/>
+    </svg>
+);
+
+export const IcoPulse = () => (
+    <svg width="16" height="16" viewBox="0 0 24 24" fill="none" stroke="currentColor" strokeWidth="2" strokeLinecap="round" strokeLinejoin="round">
+        <path d="M3 12h4l2.5-6 4 12 2.5-6H21"/>
+    </svg>
+);
+
 export const ICONS: Record<string, () => JSX.Element> = {
     users: IcoUsers,
     key:   IcoKey,
+    shield: IcoShield,
+    pulse:  IcoPulse,
 };

awg-ui/src/lib/shared.ts

@@ -5,6 +5,9 @@
 import axios from 'axios';
 // Поколение протокола AmneziaWG, на параметрах которого выдан vpn:// ключ.
 export type AwgGen = '2' | '3.1';
+// Текущая приоритетность ключа/устройства: «background» — канал занят, а он давно качает больше своей доли.
+export type Priority = 'normal' | 'background';
+
 export interface User {
     name:          string;
     ip:            string;
@@ -15,6 +18,8 @@ export interface User {
     lastHandshake: number;
     rx?:           number;
     tx?:           number;
+    priority?:     Priority;     // нет у awg-ctrl старше деления канала
+    torrent?:      boolean;      // пытался качать торренты за последние 10 минут (при включённой блокировке)
 }
 export interface ServerInfo {
     name:  string;
@@ -64,6 +69,27 @@ export interface NodeInfo {
     health:    { server: string; ip: string; gen: AwgGen; peers: number; awg_up: boolean; module: string; tools: string } | null;
 }
 
+// Деление канала (GET/PUT /api/shaping на awg-ctrl сервера).
+export interface ShapingStatus {
+    settings:  { enabled: boolean; downMbit: number; upMbit: number; auto: boolean };
+    active:    boolean;     // CAKE реально стоит на интерфейсе
+    congested: boolean;
+    heavy:     string[];    // IP устройств, переведённых в фоновый класс
+    devices:   number;      // активных устройств в окне
+    rateDown:  number;      // Мбит/с за последний тик
+    rateUp:    number;
+}
+
+// Блокировка BitTorrent (GET/PUT /api/torrent на awg-ctrl сервера).
+export interface TorrentStatus {
+    settings: { enabled: boolean };
+    active:   boolean;     // nft-таблица реально стоит
+    tcp:      boolean;     // проверяется и TCP-рукопожатие (нужен свежий nftables)
+    hits:     number;      // заблокированных попыток с последнего применения
+    seen:     { ip: string; name: string }[];   // кто пытался за последние 10 минут
+    error?:   string;
+}
+
 // Сравнение версий вида 0.3.3 (хвост после «-» не учитывается): <0 — a старше b.
 export function cmpVersion(a: string, b: string): number {
     const pa = a.split('-')[0].split('.').map(Number), pb = b.split('-')[0].split('.').map(Number);

awg-ui/src/tabs/apikeys/apikeys.css

@@ -90,3 +90,5 @@ LICENSE file in the root directory of this source tree.
 .apikey-tools-hint { margin: 0; font-size: 12px; color: var(--neutral-text); }
 .apikey-card-btns { display: flex; gap: 8px; flex-shrink: 0; }
 .apikey-card-servers { font-size: 12px; color: var(--neutral-text); }
+
+.apikey-new-servers { display: flex; flex-wrap: wrap; align-items: center; gap: 8px 16px; margin: 0 0 16px; }

awg-ui/src/tabs/apikeys/index.tsx

@@ -18,6 +18,7 @@ export default function ApiKeysPage({ token, showMsg }: PageProps) {
     const [label, setLabel]     = useState('');
     const [created, setCreated] = useState<{ label: string; key: string } | null>(null);
     const [tools, setTools]     = useState<number | null>(null);   // ключ с открытыми настройками
+    const [picked, setPicked]   = useState<number[] | null>(null);   // серверы нового ключа; null — только выбранный в сервер-баре
 
     const load = useCallback(async () => {
         try {
@@ -54,12 +55,15 @@ export default function ApiKeysPage({ token, showMsg }: PageProps) {
 
     const createKey = useCallback(async () => {
         if (!label.trim()) return;
-        const r = await apiFetch('POST', '/ui/apikeys', token, { label: label.trim(), server_id: getServerId() ?? 0 });
+        const def = getServerId() ?? 0;
+        const servers = picked ?? [def];
+        const r = await apiFetch('POST', '/ui/apikeys', token, { label: label.trim(), server_id: servers.includes(def) ? def : servers[0], servers });
         if (r.error) { showMsg(r.error); return; }
         setLabel('');
+        setPicked(null);
         setCreated({ label: r.label, key: r.key });
         await load();
-    }, [label, token, load, showMsg]);
+    }, [label, picked, token, load, showMsg]);
 
     const deleteKey = useCallback(async (id: number, lbl: string) => {
         if (!confirm('Удалить ключ «' + lbl + '»? Клиенты с ним потеряют доступ.')) return;
@@ -70,6 +74,7 @@ export default function ApiKeysPage({ token, showMsg }: PageProps) {
 
     useEffect(() => { if (token) load(); }, [token, load]);
 
+
     return (
         <>
             {/* Сервер-бар сверху рендерит App; новый ключ получает выбранный в нём сервер. */}
@@ -87,6 +92,11 @@ export default function ApiKeysPage({ token, showMsg }: PageProps) {
                     </button>
                 </div>
             </div>
+            <div className="apikey-new-servers">
+                <span className="apikey-tools-hint">Серверы нового ключа:</span>
+                <ServerPicker nodes={nodes} selected={picked ?? [getServerId() ?? 0]}
+                    onChange={next => setPicked(next)} />
+            </div>
 
             <div className="table-card">
                 <table>

awg-ui/src/tabs/apikeys/metadata.json

@@ -2,5 +2,6 @@
   "id": "apikeys",
   "label": "API-ключи",
   "icon": "key",
+  "group": "main",
   "order": 2
 }

awg-ui/src/tabs/audit/audit.css

@@ -0,0 +1,39 @@
+/*
+Copyright (c) 2026 Ivan Vasilev
+This source code is licensed under the MIT license found in the
+LICENSE file in the root directory of this source tree.
+*/
+/* Стили вкладки «Аудит». Общая дизайн-система — в App.css. */
+
+.au-head { display: flex; flex-wrap: wrap; align-items: center; gap: 8px 12px; }
+.au-run { margin-left: auto; }
+.au-hint { font-size: 13px; color: var(--neutral-text); }
+.au-notice {
+    font-size: 13px; color: var(--error-text); background: var(--error-bg);
+    border-radius: 16px; padding: 10px 16px; margin: 0;
+}
+.au-empty { font-size: 14px; color: var(--neutral-text); text-align: center; padding: 48px 0; }
+.au-pub { display: inline-block; max-width: 340px; overflow: hidden; text-overflow: ellipsis; vertical-align: middle; font-family: var(--mono); font-size: 12px; }
+.au-table td, .au-table th { white-space: nowrap; }
+
+/* мобильный: таблица скрыта (.table-card), то же — карточками */
+.au-cards { list-style: none; margin: 0; padding: 0; display: none; flex-direction: column; gap: 8px; }
+.au-card { display: flex; flex-direction: column; gap: 4px; background: var(--surface-container); border-radius: 16px; padding: 12px 16px; }
+.au-card-top { display: flex; align-items: center; justify-content: space-between; gap: 8px; }
+.au-card .au-pub { max-width: 100%; }
+@media (max-width: 640px) { .au-cards { display: flex; } }
+
+.au-btns { display: flex; flex-wrap: wrap; gap: 8px; margin-left: auto; }
+.au-run { margin-left: 0; }
+
+.au-box { display: flex; flex-direction: column; gap: 10px; background: var(--surface-container); border-radius: 16px; padding: 12px 16px; }
+.au-box-title { margin: 0; font-size: 14px; font-weight: 500; }
+.au-setting { display: flex; align-items: center; justify-content: space-between; gap: 12px; }
+.au-setting-text { display: flex; flex-direction: column; gap: 2px; min-width: 0; }
+.au-setting-name { font-size: 14px; }
+.au-setting-ctl { display: inline-flex; align-items: center; gap: 8px; }
+.au-max { width: 88px !important; }
+.au-select { width: auto !important; }
+.au-log { list-style: none; margin: 0; padding: 0; display: flex; flex-direction: column; gap: 6px; }
+.au-log li { display: flex; flex-wrap: wrap; align-items: center; gap: 4px 10px; font-size: 13px; }
+.au-log .au-pub { max-width: 240px; }

awg-ui/src/tabs/audit/index.tsx

@@ -0,0 +1,193 @@
+// Copyright (c) 2026 Ivan Vasilev
+// This source code is licensed under the MIT license found in the
+// LICENSE file in the root directory of this source tree.
+import { useState, useEffect, useCallback } from 'react';
+import { apiFetch, timeAgo, type NodeInfo, type PageProps } from '../../lib/shared';
+import { IcoRefresh, IcoTrash } from '../../components/icons';
+import { serverName } from '../../components/ServerPicker';
+import './audit.css';
+
+// Вкладка «Аудит»: core периодически обходит все серверы и ищет «мёртвых» пиров — живых на сервере,
+// хотя панель про них не знает (мастер-ключ удалён, а пир остался). Снимает только подтверждённых
+// (мёртвых два прохода подряд): автоматически, если включено в настройках, или кнопкой.
+// Отчёт и очистку считает awg-ui/sub.ts (/ui/masterkeys/audit*).
+interface AuditPeer { pub_key: string; owner?: string; key?: string | null; online: boolean; lastHandshake: number; seen_before?: boolean }
+interface AuditEntry {
+    server_id: number; status: 'ok' | 'offline' | 'error'; ghosts_checked: boolean;
+    ghosts: AuditPeer[]; orphans: AuditPeer[]; foreign: number; blocked?: number;
+}
+interface Settings { clean: boolean; every_h: number; max: number }
+interface Cleaned { at: number; server_id: number; pub_key: string; kind: 'ghost' | 'orphan'; key?: string | null; auto: boolean }
+interface AuditData { enabled: boolean; settings: Settings; report: { at: number; servers: AuditEntry[] } | null; cleaned: Cleaned[] }
+
+const PERIODS = [1, 3, 6, 12, 24];
+
+const errText = (e: any): string => e?.response?.data?.error ?? 'Ошибка запроса';
+
+export default function AuditPage({ token, showMsg }: PageProps) {
+    const [audit, setAudit] = useState<AuditData | null>(null);
+    const [nodes, setNodes] = useState<NodeInfo[]>([]);
+    const [busy, setBusy]   = useState(false);
+    const [maxEdit, setMaxEdit] = useState('');
+
+    const load = useCallback(async () => {
+        try {
+            setAudit(await apiFetch('GET', '/ui/masterkeys/audit', token));
+            apiFetch('GET', '/ui/nodes', token).then(r => setNodes(r.nodes ?? [])).catch(() => {});
+        } catch { showMsg('Ошибка загрузки аудита'); }
+    }, [token, showMsg]);
+
+    useEffect(() => { if (token) load(); }, [token, load]);
+
+    const call = useCallback(async (method: string, path: string, ok: string, body?: object) => {
+        setBusy(true);
+        try { setAudit(await apiFetch(method, `/ui/masterkeys/audit${path}`, token, body)); showMsg(ok); }
+        catch (e) { showMsg(errText(e)); }
+        finally { setBusy(false); }
+    }, [token, showMsg]);
+    const run = () => call('POST', '', 'Аудит выполнен');
+    const save = (patch: Partial<Settings>) => call('PUT', '/settings', 'Настройки сохранены', patch);
+
+    if (!audit) return null;
+    if (!audit.enabled) return <p className="au-empty">Аудит выключен на этой панели: его проводит только core.</p>;
+
+    const { settings } = audit;
+    const servers = audit.report?.servers ?? [];
+    const dead = servers.reduce((n, e) => n + e.ghosts.length + e.orphans.length, 0);
+    const bad = servers.filter(e => e.status !== 'ok');
+    const confirmed = servers.reduce((n, e) => n + [...e.ghosts, ...e.orphans].filter(p => p.seen_before).length, 0);
+    const blocked = servers.filter(e => e.blocked);
+    const rows = servers.flatMap(e => [
+        ...e.ghosts.map(p => ({ e, p, why: 'Есть в ядре, у awg-ctrl записи нет' })),
+        ...e.orphans.map(p => ({ e, p, why: 'Панели не нужен, не снят' })),
+    ]);
+    const state = (p: AuditPeer) => (
+        <span className={`chip chip--${p.online ? 'error' : 'offline'}`}>
+            <span className="chip-dot" />{p.online ? 'Онлайн' : p.lastHandshake ? `был ${timeAgo(p.lastHandshake)} назад` : 'не подключался'}
+        </span>
+    );
+    const confirm = (p: AuditPeer) => (
+        <span className="au-hint">{p.seen_before ? 'подтверждён' : 'найден впервые — снимется, если останется и в следующий раз'}</span>
+    );
+
+    return (
+        <>
+            <section className="au-head">
+                <span className={`chip chip--${!audit.report ? 'offline' : dead ? 'error' : 'online'}`}>
+                    <span className="chip-dot" />
+                    {!audit.report ? 'Аудит ещё не проводился' : dead ? `Мёртвых пиров: ${dead}` : 'Мёртвых пиров нет'}
+                </span>
+                {audit.report && (
+                    <span className="au-hint">
+                        Проверено {timeAgo(audit.report.at)} назад · серверов: {servers.length} · раз в {settings.every_h} ч
+                    </span>
+                )}
+                <div className="au-btns">
+                    {confirmed > 0 && (
+                        <button className="btn btn--tonal" disabled={busy}
+                            onClick={() => window.confirm(`Снять с серверов подтверждённых пиров: ${confirmed}?`) && call('POST', '/clean', 'Очистка выполнена')}>
+                            <IcoTrash /> Снять подтверждённых ({confirmed})
+                        </button>
+                    )}
+                    <button className="btn btn--tonal" disabled={busy} onClick={run}>
+                        <IcoRefresh /> {busy ? 'Работаем…' : 'Проверить сейчас'}
+                    </button>
+                </div>
+            </section>
+
+            <section className="au-box">
+                <h4 className="au-box-title">Настройки</h4>
+                <label className="au-setting">
+                    <span className="au-setting-text">
+                        <span className="au-setting-name">Снимать мёртвых автоматически</span>
+                        <span className="au-hint">Только тех, кто мёртв два прохода подряд. Ручной проход ничего не снимает.</span>
+                    </span>
+                    <input type="checkbox" checked={settings.clean} disabled={busy} onChange={e => save({ clean: e.target.checked })} />
+                </label>
+                <div className="au-setting">
+                    <span className="au-setting-text">
+                        <label className="au-setting-name" htmlFor="au-every">Период проверки</label>
+                        <span className="au-hint">Как часто core обходит серверы</span>
+                    </span>
+                    <select id="au-every" className="field au-select" value={settings.every_h} disabled={busy}
+                        onChange={e => save({ every_h: Number(e.target.value) })}>
+                        {[...new Set([...PERIODS, settings.every_h])].sort((a, b) => a - b).map(h => <option key={h} value={h}>{h} ч</option>)}
+                    </select>
+                </div>
+                <div className="au-setting">
+                    <span className="au-setting-text">
+                        <label className="au-setting-name" htmlFor="au-max">Предел за проход</label>
+                        <span className="au-hint">Если на сервере мёртвых больше — автоочистка ничего не снимает и только сообщает (защита от сбоя)</span>
+                    </span>
+                    <span className="au-setting-ctl">
+                        <input id="au-max" className="field au-max" type="number" min={1} max={1000}
+                            value={maxEdit || String(settings.max)} onChange={e => setMaxEdit(e.target.value)} />
+                        <button className="btn btn--tonal" disabled={busy || !maxEdit || Number(maxEdit) === settings.max}
+                            onClick={() => save({ max: Number(maxEdit) }).then(() => setMaxEdit(''))}>Сохранить</button>
+                    </span>
+                </div>
+            </section>
+
+            {bad.length > 0 && (
+                <p className="au-notice">
+                    Не проверены: {bad.map(e => `${serverName(nodes, e.server_id)} (${e.status === 'offline' ? 'не в сети' : 'ошибка'})`).join(', ')}
+                </p>
+            )}
+            {blocked.length > 0 && (
+                <p className="au-notice">
+                    Автоочистка пропустила: {blocked.map(e => `${serverName(nodes, e.server_id)} (${e.blocked} пиров при пределе ${settings.max})`).join(', ')}. Проверьте список и снимите вручную.
+                </p>
+            )}
+            {servers.some(e => e.status === 'ok' && !e.ghosts_checked) && (
+                <p className="au-notice">Часть серверов на старой версии awg-ctrl: пиров, которые есть только в ядре, там не видно.</p>
+            )}
+
+            {rows.length > 0 && (
+                <>
+                    <div className="table-card au-table-card">
+                        <table>
+                            <thead><tr><th>Сервер</th><th>Публичный ключ</th><th>Причина</th><th>Мастер-ключ</th><th>Состояние</th></tr></thead>
+                            <tbody>
+                                {rows.map(({ e, p, why }) => (
+                                    <tr key={`${e.server_id}:${p.pub_key}`}>
+                                        <td>{serverName(nodes, e.server_id)}</td>
+                                        <td className="td-mono"><code className="au-pub" title={p.pub_key}>{p.pub_key}</code></td>
+                                        <td>{why}</td>
+                                        <td>{p.key ?? '—'}</td>
+                                        <td>{state(p)}<br />{confirm(p)}</td>
+                                    </tr>
+                                ))}
+                            </tbody>
+                        </table>
+                    </div>
+                    <ul className="au-cards">
+                        {rows.map(({ e, p, why }) => (
+                            <li className="au-card" key={`${e.server_id}:${p.pub_key}`}>
+                                <div className="au-card-top"><b>{serverName(nodes, e.server_id)}</b>{state(p)}</div>
+                                <code className="au-pub" title={p.pub_key}>{p.pub_key}</code>
+                                <span className="au-hint">{why}{p.key ? ` · ${p.key}` : ''}</span>
+                                {confirm(p)}
+                            </li>
+                        ))}
+                    </ul>
+                </>
+            )}
+            {audit.cleaned.length > 0 && (
+                <section className="au-box">
+                    <h4 className="au-box-title">Снято</h4>
+                    <ul className="au-log">
+                        {audit.cleaned.slice(0, 20).map(c => (
+                            <li key={`${c.at}:${c.pub_key}`}>
+                                <span className="au-hint">{timeAgo(c.at)} назад</span>
+                                <span>{serverName(nodes, c.server_id)}</span>
+                                <code className="au-pub" title={c.pub_key}>{c.pub_key}</code>
+                                <span className="au-hint">{c.kind === 'ghost' ? 'был только в ядре' : 'лишний у awg-ctrl'}{c.key ? ` · ${c.key}` : ''} · {c.auto ? 'автоматически' : 'вручную'}</span>
+                            </li>
+                        ))}
+                    </ul>
+                </section>
+            )}
+            {audit.report && rows.length === 0 && <p className="au-empty">Всё чисто: лишних пиров на серверах нет.</p>}
+        </>
+    );
+}

awg-ui/src/tabs/audit/metadata.json

@@ -0,0 +1,11 @@
+{
+  "id": "audit",
+  "label": "Аудит",
+  "icon": "shield",
+  "group": "server",
+  "order": 1.8,
+  "chrome": {
+    "serverBar": false,
+    "restart": false
+  }
+}

awg-ui/src/tabs/index.ts

@@ -4,7 +4,7 @@
 // Автообнаружение вкладок. Каждая вкладка — самодостаточная папка tabs/<name>/:
 //   index.tsx      — компонент + логика
 //   <name>.css     — стили вкладки (импортит сам компонент)
-//   metadata.json  — { id, label, icon, order?, chrome? } (манифест: описание + порядок)
+//   metadata.json  — { id, label, icon, group?, order?, chrome? } (манифест: описание, группа меню, порядок)
 // Реестр сам находит все папки через import.meta.glob и собирает «живые» части
 // (Page-компонент, Icon по имени из ICONS) к метадате. Добавить вкладку = просто
 // создать папку с index.tsx и metadata.json — этот файл трогать НЕ нужно.
@@ -21,12 +21,20 @@ export interface TabChrome {
     restart?:   boolean;
 }
 
+// Группы меню: порядок здесь = порядок заголовков в сайдбаре. Новая группа — строка сюда.
+export const TAB_GROUPS = [
+    { id: 'main',   label: 'Основное' },
+    { id: 'server', label: 'О сервере' },
+] as const;
+export type TabGroupId = (typeof TAB_GROUPS)[number]['id'];
+
 // Сериализуемая часть из metadata.json.
 export interface TabMeta {
     id:      string;
     label:   string;
     icon:    string;     // имя иконки → ICONS
-    order?:  number;     // порядок в меню (по возрастанию; без него — 0)
+    group:   TabGroupId; // группа меню; без поля — 'main'
+    order?:  number;     // порядок внутри группы (по возрастанию; без него — 0)
     chrome?: TabChrome;
 }
 
@@ -58,10 +66,15 @@ function toMeta(name: string, raw: unknown): TabMeta {
     if (m.chrome !== undefined && (typeof m.chrome !== 'object' || m.chrome === null)) {
         throw new Error(`tabs/${name}/metadata.json: "chrome" должно быть объектом`);
     }
+    const group = (m.group ?? 'main') as string;
+    if (!TAB_GROUPS.some(g => g.id === group)) {
+        throw new Error(`tabs/${name}/metadata.json: "group" должно быть одним из: ${TAB_GROUPS.map(g => g.id).join(', ')}`);
+    }
     return {
         id:     str('id'),
         label:  str('label'),
         icon:   str('icon'),
+        group:  group as TabGroupId,
         order:  m.order as number | undefined,
         chrome: m.chrome as TabChrome | undefined,
     };
@@ -80,7 +93,15 @@ export const TABS: TabDef[] = Object.entries(metas)
         }
         return { ...meta, Icon: ICONS[meta.icon], Page: page };
     })
-    .sort((a, b) => (a.order ?? 0) - (b.order ?? 0));
+    // сначала по группе (как в TAB_GROUPS), внутри группы — по order
+    .sort((a, b) =>
+        TAB_GROUPS.findIndex(g => g.id === a.group) - TAB_GROUPS.findIndex(g => g.id === b.group)
+        || (a.order ?? 0) - (b.order ?? 0));
+
+// Вкладки по группам для меню; пустые группы не показываем.
+export const TABS_BY_GROUP = TAB_GROUPS
+    .map(g => ({ ...g, tabs: TABS.filter(t => t.group === g.id) }))
+    .filter(g => g.tabs.length > 0);
 
 // id вкладок используются как ключ активной вкладки — дубли ломают переключение.
 const ids = TABS.map(t => t.id);

awg-ui/src/tabs/masterkeys/index.tsx

@@ -3,9 +3,11 @@
 // LICENSE file in the root directory of this source tree.
 import { Fragment, useState, useEffect, useCallback } from 'react';
 import QRCode from 'qrcode';
-import { apiFetch, copyText, bytes, timeAgo, type NodeInfo, type PageProps } from '../../lib/shared';
-import { IcoPlus, IcoTrash, IcoCopy, IcoQR, IcoKey, IcoRefresh, IcoSettings } from '../../components/icons';
+import { apiFetch, copyText, bytes, timeAgo, getServerId, type NodeInfo, type PageProps, type Priority } from '../../lib/shared';
+import { IcoPlus, IcoTrash, IcoCopy, IcoQR, IcoKey, IcoRefresh, IcoSettings, IcoGlobe } from '../../components/icons';
 import ServerPicker, { serverName } from '../../components/ServerPicker';
+import PriorityChip from '../../components/PriorityChip';
+import TorrentChip from '../../components/TorrentChip';
 import './masterkeys.css';
 
 // Вкладка «Мастер-ключи»: sen://-подписки для SenAWG. Мастер-ключ — это ссылка
@@ -15,8 +17,9 @@ import './masterkeys.css';
 interface MasterKey { id: number; uuid: string; label: string; device_limit: number; devices: number; servers: number[]; created_at: number; deleting?: number[] }
 interface Device {
     id: number; device_id: string; device_name: string; platform: string; version: string; created_at: number; last_seen: number | null;
-    rekey_requested: boolean; online: boolean; lastHandshake: number; rx: number; tx: number;
+    rekey_requested: boolean; online: boolean; lastHandshake: number; rx: number; tx: number; priority?: Priority; torrent?: boolean;
     servers_total: number; servers_ok: number;   // на скольких серверах ключа уже стоит его текущий ключ
+    ips?: { server_id: number; ip: string }[];   // IP на каждом сервере ключа (старая панель не отдаёт)
 }
 
 // Устройство ещё не на всех серверах ключа (нода не в сети при регистрации или смене ключа) —
@@ -30,6 +33,18 @@ const platformLabel = (d: Device): string =>
 
 const errText = (e: any): string => e?.response?.data?.error ?? 'Ошибка запроса';
 
+// Статус — как у пользователей: «онлайн», иначе сколько прошло с последнего handshake.
+const statusChip = (d: Device) => (
+    <span className={`chip chip--${d.online ? 'online' : 'offline'}`}>
+        <span className="chip-dot" />
+        {d.online ? 'онлайн' : d.lastHandshake ? timeAgo(d.lastHandshake) + ' назад' : 'никогда'}
+    </span>
+);
+
+// IP устройства на выбранном сервере (на каждом сервере ключа он свой), иначе — на первом.
+const ipOf = (d: Device): string =>
+    (d.ips?.find(x => x.server_id === getServerId()) ?? d.ips?.[0])?.ip ?? '—';
+
 export default function MasterKeysPage({ token, showMsg }: PageProps) {
     const [keys, setKeys]       = useState<MasterKey[]>([]);
     const [enabled, setEnabled] = useState(true);
@@ -252,17 +267,51 @@ export default function MasterKeysPage({ token, showMsg }: PageProps) {
         </div>
     );
 
-    // UUID ключа в строке списка — как ID устройств под ним (та же ширина и обрезка),
-    // полностью — в подсказке, по клику копируется.
-    const uuidCell = (k: MasterKey) => (
-        <span className="tip-wrap mk-uuid-wrap" data-tip={`UUID ${k.uuid} · нажми, чтобы скопировать`}>
-            <button className="mk-uuid-btn" aria-label={`Скопировать UUID ${k.uuid}`}
-                onClick={() => copyText(k.uuid).then(() => showMsg('UUID скопирован'), () => showMsg('Не удалось скопировать'))}>
-                <code className="mk-device-id">{k.uuid}</code>
-            </button>
+    // Метка ключа и под ней UUID — коротко, чтобы не раздувать колонку «Имя». Полностью — в подсказке,
+    // по клику копируется.
+    const nameCell = (k: MasterKey) => (
+        <span className="name-stack">
+            {k.label}
+            <span className="tip-wrap" data-tip={`UUID ${k.uuid} · нажми, чтобы скопировать`}>
+                <button className="copy-id" aria-label={`Скопировать UUID ${k.uuid}`}
+                    onClick={() => copyText(k.uuid).then(() => showMsg('UUID скопирован'), () => showMsg('Не удалось скопировать'))}>
+                    {k.uuid.slice(0, 8)}…
+                </button>
+            </span>
         </span>
     );
 
+    // Сводка по устройствам ключа в его строке — видна и у свёрнутого ключа.
+    const summary = (list: Device[]) => {
+        if (!list.length) return <><td></td><td></td><td colSpan={2}></td><td></td><td></td></>;
+        const on = list.filter(d => d.online).length;
+        const last = Math.max(...list.map(d => d.lastHandshake || 0));
+        const torrent = list.some(d => d.torrent);
+        const prio = list.some(d => d.priority === 'background') ? 'background' : list.find(d => d.priority)?.priority;
+        return (
+            <>
+                <td>
+                    <span className={`chip chip--${on ? 'online' : 'offline'}`}>
+                        <span className="chip-dot" />
+                        {on ? `онлайн: ${on} из ${list.length}` : last ? timeAgo(last) + ' назад' : 'никогда'}
+                    </span>
+                </td>
+                <td><span className="user-chips"><PriorityChip priority={prio} torrent={torrent} /><TorrentChip torrent={torrent} /></span></td>
+                <td colSpan={2}></td>
+                <td>{bytes(list.reduce((a, d) => a + d.rx, 0))}</td>
+                <td>{bytes(list.reduce((a, d) => a + d.tx, 0))}</td>
+            </>
+        );
+    };
+
+    const ipCell = (d: Device) => {
+        const all = d.ips ?? [];
+        const ip = <code className="mk-ip">{ipOf(d)}</code>;
+        return all.length > 1
+            ? <span className="tip-wrap" data-tip={all.map(x => `${serverName(nodes, x.server_id)}: ${x.ip}`).join(' · ')}>{ip}</span>
+            : ip;
+    };
+
     const caret = (k: MasterKey) => (
         <button className={`mk-caret${folded.has(k.id) ? ' mk-caret--folded' : ''}`}
             aria-label={folded.has(k.id) ? 'Развернуть' : 'Свернуть'} aria-expanded={!folded.has(k.id)}
@@ -277,12 +326,17 @@ export default function MasterKeysPage({ token, showMsg }: PageProps) {
                         <span className="mk-device-name">{d.device_name || 'Устройство'}</span>
                         <code className="mk-device-id" title={`ID устройства: ${d.device_id}`}>{d.device_id}</code>
                     </span>
-                    <span className="mk-device-sub">{platformLabel(d)} · был {d.last_seen ? timeAgo(d.last_seen) + ' назад' : 'никогда'}
+                    <span className="mk-device-sub">{platformLabel(d)}
                         {d.rekey_requested ? ' · ждёт смены ключа' : ''}{syncLabel(d)}</span>
                 </div>
-                <span className={`chip chip--${d.online ? 'online' : 'offline'}`}>
-                    <span className="chip-dot" />{d.online ? 'Онлайн' : 'Офлайн'}
-                </span>
+                {statusChip(d)}
+                {/* как строка IP в карточке пользователя: адрес и чипы приоритета/торрентов */}
+                <div className="mk-device-ip">
+                    <IcoGlobe />
+                    <span className="mk-ip">{ipOf(d)}</span>
+                    <PriorityChip priority={d.priority} torrent={d.torrent} />
+                    <TorrentChip torrent={d.torrent} />
+                </div>
                 <div className="mk-device-traffic">
                     <span className="mk-metric"><i className="mk-metric-name" data-sfx=" rx">↓</i><b>{bytes(d.rx)}</b></span>
                     <span className="mk-metric"><i className="mk-metric-name" data-sfx=" tx">↑</i><b>{bytes(d.tx)}</b></span>
@@ -316,8 +370,8 @@ export default function MasterKeysPage({ token, showMsg }: PageProps) {
                 <table className="mk-table">
                     <thead>
                         <tr>
-                            <th>Имя</th><th>ID устройства</th><th>Платформа</th><th>Статус</th>
-                            <th>↓ rx</th><th>↑ tx</th><th>Был</th><th>Устройства</th><th></th>
+                            <th>Имя</th><th>Статус</th><th>Приоритет</th><th>IP</th><th>Платформа</th>
+                            <th>↓ rx</th><th>↑ tx</th><th>Устройства</th><th></th>
                         </tr>
                     </thead>
                     <tbody>
@@ -326,9 +380,8 @@ export default function MasterKeysPage({ token, showMsg }: PageProps) {
                         ) : keys.map(k => {
                             if (k.deleting) return (
                                 <tr key={k.id} className="mk-tr-master mk-last">
-                                    <td><span className="mk-name"><IcoKey />{k.label}</span></td>
-                                    <td className="td-mono">{uuidCell(k)}</td>
-                                    <td colSpan={7}>{deletingChip(k)}</td>
+                                    <td><span className="mk-name"><IcoKey />{nameCell(k)}</span></td>
+                                    <td colSpan={8}>{deletingChip(k)}</td>
                                 </tr>
                             );
                             const list = devs[k.id] ?? [];
@@ -337,28 +390,35 @@ export default function MasterKeysPage({ token, showMsg }: PageProps) {
                             return (
                                 <Fragment key={k.id}>
                                     <tr className="mk-tr-master">
-                                        <td><span className="mk-name">{caret(k)}<IcoKey />{k.label}</span></td>
-                                        <td className="td-mono">{uuidCell(k)}</td>
-                                        <td colSpan={5}></td>
+                                        <td><span className="mk-name">{caret(k)}<IcoKey />{nameCell(k)}</span></td>
+                                        {summary(list)}
                                         <td>{meter(k, list.length)}</td>
                                         <td className="td-actions mk-td-actions">{actions(k)}</td>
                                     </tr>
                                     {tools === k.id && <tr className="mk-tr-tools"><td colSpan={9}>{toolbox(k)}</td></tr>}
                                     {open && list.map((d, i) => (
                                         <tr key={d.id} className={`mk-tr-device${i === list.length - 1 && free === 0 ? ' mk-last' : ''}`}>
-                                            <td><span className="mk-indent">{d.device_name || 'Устройство'}</span></td>
-                                            <td className="td-mono"><code className="mk-device-id" title={d.device_id}>{d.device_id}</code></td>
-                                            <td>{platformLabel(d)}</td>
                                             <td>
-                                                <span className={`chip chip--${d.online ? 'online' : 'offline'}`}>
-                                                    <span className="chip-dot" />{d.online ? 'Онлайн' : 'Офлайн'}
+                                                <span className="mk-indent">
+                                                    <span className="name-stack">
+                                                        {d.device_name || 'Устройство'}
+                                                        <span className="tip-wrap" data-tip={`ID устройства ${d.device_id} · нажми, чтобы скопировать`}>
+                                                            <button className="copy-id" aria-label={`Скопировать ID устройства ${d.device_id}`}
+                                                                onClick={() => copyText(d.device_id).then(() => showMsg('ID устройства скопирован'), () => showMsg('Не удалось скопировать'))}>
+                                                                {d.device_id.slice(0, 8)}…
+                                                            </button>
+                                                        </span>
+                                                    </span>
                                                 </span>
-                                            </td>
-                                            <td className="td-mono">{bytes(d.rx)}</td>
-                                            <td className="td-mono">{bytes(d.tx)}</td>
-                                            <td>{d.last_seen ? timeAgo(d.last_seen) + ' назад' : 'никогда'}
                                                 {d.rekey_requested && <span className="mk-flag"> · ждёт смены ключа</span>}
-                                                {syncLabel(d) && <span className="mk-flag">{syncLabel(d)}</span>}</td>
+                                                {syncLabel(d) && <span className="mk-flag">{syncLabel(d)}</span>}
+                                            </td>
+                                            <td>{statusChip(d)}</td>
+                                            <td><span className="user-chips"><PriorityChip priority={d.priority} torrent={d.torrent} /><TorrentChip torrent={d.torrent} /></span></td>
+                                            <td className="td-mono">{ipCell(d)}</td>
+                                            <td>{platformLabel(d)}</td>
+                                            <td>{bytes(d.rx)}</td>
+                                            <td>{bytes(d.tx)}</td>
                                             <td></td>
                                             <td className="td-actions mk-td-actions">{deviceActions(d)}</td>
                                         </tr>

awg-ui/src/tabs/masterkeys/masterkeys.css

@@ -26,13 +26,6 @@ LICENSE file in the root directory of this source tree.
 .mk-tr-master td { background: var(--surface-container); font-weight: 500; padding-top: 6px; padding-bottom: 6px; }
 .mk-tr-master:hover td { background: var(--surface-container); }
 .mk-name { display: inline-flex; align-items: center; gap: 8px; color: var(--primary); }
-/* UUID ключа в строке: выглядит как ID устройства, по клику копирует */
-.mk-uuid-btn {
-    background: none; border: 0; padding: 0; margin: 0;
-    cursor: pointer; font: inherit; font-weight: 400; color: inherit; line-height: inherit;
-}
-.mk-uuid-btn:hover .mk-device-id { color: var(--primary); }
-.mk-uuid-btn:focus-visible { outline: 2px solid var(--primary); outline-offset: 2px; border-radius: 4px; }
 .mk-master-uuid {
     display: block;
     font-family: var(--mono); font-size: 12px; font-weight: 400;
@@ -46,6 +39,9 @@ LICENSE file in the root directory of this source tree.
 .mk-tr-tools:hover { background: transparent; }
 .mk-tr-device td, .mk-tr-free td { padding-top: 10px; padding-bottom: 10px; }
 .mk-flag { color: var(--neutral-text); font-size: 12px; }
+/* чипы приоритета и торрентов в одной ячейке — как во вкладке «Пользователи» */
+.mk-table .user-chips { display: inline-flex; flex-wrap: nowrap; gap: 6px; }
+.mk-ip { font-family: var(--mono); }
 /* иерархия: линия слева от имени и «ножка» к каждой строке; у последней линия обрывается */
 .mk-tr-device td:first-child, .mk-tr-free td:first-child {
     background: linear-gradient(var(--outline), var(--outline)) 30px 0 / 2px 100% no-repeat;
@@ -210,6 +206,13 @@ LICENSE file in the root directory of this source tree.
 }
 .mk-device-name { font-size: 14px; font-weight: 500; color: var(--on-surface); }
 .mk-device-sub  { font-size: 12px; color: var(--neutral-text); }
+.mk-device-ip {
+    display: flex; flex-wrap: wrap; align-items: center; gap: 8px;
+    width: 100%;
+    color: var(--neutral-text);
+}
+.mk-device-ip .mk-ip { font-size: 13px; }
+.mk-device-ip .tip-wrap { width: auto; }
 .mk-device-traffic { display: flex; gap: 12px; font-family: var(--mono); font-size: 12px; color: var(--neutral-text); }
 .mk-metric { display: inline-flex; gap: 4px; }
 .mk-metric i, .mk-metric b { font-style: normal; font-weight: 400; }

awg-ui/src/tabs/masterkeys/metadata.json

@@ -2,5 +2,6 @@
   "id": "masterkeys",
   "label": "Мастер-ключи",
   "icon": "key",
+  "group": "main",
   "order": 1.5
 }

awg-ui/src/tabs/monitor/index.tsx

@@ -0,0 +1,361 @@
+// Copyright (c) 2026 Ivan Vasilev
+// This source code is licensed under the MIT license found in the
+// LICENSE file in the root directory of this source tree.
+import { useState, useEffect, useCallback, useRef } from 'react';
+import { apiFetch, copyText, getServerId, type NodeInfo, type PageProps } from '../../lib/shared';
+import { IcoCopy, IcoTrash } from '../../components/icons';
+import LineChart from '../../components/LineChart';
+import './monitor.css';
+
+// Вкладка «Монитор»: встроенный Prometheus и основные графики.
+// Кнопка «Подключить Prometheus» просит локальный awg-ctrl поставить его (`awg-ctrl monitor install`, root;
+// сама панель пакетов не ставит). Графики читают Prometheus через фиксированные запросы панели
+// (awg-ui/monitor.ts).
+interface Status {
+    ready: boolean; can_install: boolean; command: string;
+    job: { action: 'install' | 'remove'; running: boolean; exit: number | null; log: string } | null;   // последняя операция
+}
+type Pts = [number, number][];
+interface Overview {
+    range: string; step: number; from: number; to: number;
+    servers: {
+        id: number; name: string; ok: boolean; down: number | null; up: number | null; online: number | null; heavy: number | null; congested: boolean;
+        cpu: number | null; mem: number | null; cores: number | null; mem_total: number | null;
+        used_down: number | null; used_up: number | null;   // байт за весь период
+    }[];
+    total: Series;
+}
+interface Series { down: Pts; up: Pts; online: Pts; heavy: Pts; drops: Pts; cpu: Pts; mem: Pts }
+
+const RANGES: [string, string][] = [['1h', '1 час'], ['6h', '6 часов'], ['24h', '24 часа'], ['7d', '7 дней'], ['30d', '30 дней']];
+
+const nf = (v: number, d = 1) => v.toLocaleString('ru-RU', { maximumFractionDigits: d });
+// Скорость в битах/с → «12,4 Мбит/с»
+function rate(v: number, d = 1): string {
+    if (v >= 1e9) return `${nf(v / 1e9, d)} Гбит/с`;
+    if (v >= 1e6) return `${nf(v / 1e6, d)} Мбит/с`;
+    if (v >= 1e3) return `${nf(v / 1e3, d)} Кбит/с`;
+    return `${nf(v, 0)} бит/с`;
+}
+const lastOf = (p: Pts) => (p.length ? p[p.length - 1][1] : null);
+// Полоска нагрузки: цвет заливки — серьёзность (норма → внимание → опасно), дорожка — светлая ступень той же шкалы.
+// Цифра рядом всегда есть: цвет не единственный носитель смысла.
+const level = (v: number) => (v >= 90 ? 'mon-bar--bad' : v >= 70 ? 'mon-bar--warn' : '');
+function Bar({ v, label }: { v: number | null | undefined; label: string }) {
+    const pct = v == null ? 0 : Math.min(100, Math.max(0, v));
+    return (
+        <span className="mon-bar" role="meter" aria-label={label} aria-valuemin={0} aria-valuemax={100}
+            aria-valuenow={v == null ? undefined : Math.round(pct)}>
+            <i className={v == null ? '' : level(pct)} style={{ width: `${pct}%` }} />
+        </span>
+    );
+}
+// Прогресс операции из строк «N/M  шаг», которые печатает сам установщик (cli/src/monitor.ts). Шаг N считаем
+// выполненным наполовину: так полоска не стоит на нуле, пока идёт долгий apt, и не обещает больше, чем известно.
+const STEP = /^(\d+)\/(\d+)\s+(.+)$/;
+function JobProgress({ job, starting }: { job: Status['job']; starting: boolean }) {
+    let step: [number, number, string] | null = null;
+    for (const l of job?.log.split('\n') ?? []) { const m = STEP.exec(l.trim()); if (m) step = [Number(m[1]), Number(m[2]), m[3]]; }
+    const failed = !!job && job.exit !== null && job.exit !== 0;
+    const done   = !!job && job.exit === 0;
+    const pct    = done ? 100 : step ? ((step[0] - 0.5) / step[1]) * 100 : 0;
+    const label  = failed ? `Не удалось (код ${job!.exit})`
+        : done ? (job!.action === 'install' ? 'Готово' : 'Удалено')
+        : step ? `Шаг ${step[0]} из ${step[1]}: ${step[2]}` : 'Запуск…';
+    return (
+        <div className="mon-progress" aria-live="polite">
+            <span className={`mon-pbar${failed ? ' mon-pbar--bad' : done ? ' mon-pbar--ok' : !step && (starting || job?.running) ? ' mon-pbar--wait' : ''}`}
+                role="progressbar" aria-label="Ход операции" aria-valuemin={0} aria-valuemax={100} aria-valuenow={Math.round(pct)}>
+                <i style={{ width: `${pct}%` }} />
+            </span>
+            <span className="mon-progress-label">{label}</span>
+        </div>
+    );
+}
+const gb = (b: number) => `${nf(b / 2 ** 30, 1)} ГБ`;
+// Объём трафика — десятичные единицы, как считают провайдеры: 1 ТБ = 10¹² байт
+function vol(b: number): string {
+    if (b >= 1e12) return `${nf(b / 1e12, 2)} ТБ`;
+    if (b >= 1e9)  return `${nf(b / 1e9, 1)} ГБ`;
+    return `${nf(b / 1e6, 0)} МБ`;
+}
+
+export default function MonitorPage({ token, showMsg }: PageProps) {
+    const [status, setStatus]   = useState<Status | null>(null);
+    const [range, setRange]     = useState('1h');
+    const [ov, setOv]           = useState<Overview | null>(null);
+    const [ovErr, setOvErr]     = useState('');
+    const [loading, setLoading] = useState(false);
+    const [pending, setPending] = useState<'install' | 'remove' | null>(null);     // операция запущена из этой вкладки
+    const [server, setServer] = useState<NodeInfo | null>(null);     // показанный сервер: выбран в другой вкладке, здесь не меняется
+    const alive = useRef(true);
+    // StrictMode монтирует эффект дважды: флаг надо вернуть в true, иначе все ответы отбрасываются
+    useEffect(() => { alive.current = true; return () => { alive.current = false; }; }, []);
+
+    const loadStatus = useCallback(async () => {
+        try { const s = await apiFetch('GET', '/ui/monitor', token) as Status; if (alive.current) setStatus(s); return s; }
+        catch { return null; }
+    }, [token]);
+
+    const loadOverview = useCallback(async () => {
+        setLoading(true);
+        try {
+            const o = await apiFetch('GET', `/ui/monitor/overview?range=${range}&server=${getServerId() ?? 0}`, token) as Overview;
+            if (alive.current) { setOv(o); setOvErr(''); }
+        } catch (e: any) { if (alive.current) setOvErr(e?.response?.data?.error ?? 'Не удалось получить данные'); }
+        finally { if (alive.current) setLoading(false); }
+    }, [token, range]);
+
+    useEffect(() => { void loadStatus(); }, [loadStatus]);
+
+    // Название и состояние сервера для заголовка; список серверов на этой вкладке не показываем
+    useEffect(() => {
+        const load = () => apiFetch('GET', '/ui/nodes', token)
+            .then(r => { if (alive.current) setServer((r.nodes as NodeInfo[]).find(n => n.id === (getServerId() ?? 0)) ?? null); })
+            .catch(() => { /* заголовок необязателен */ });
+        void load();
+        const t = setInterval(load, 15000);
+        return () => clearInterval(t);
+    }, [token]);
+
+    // Пока Prometheus готов — обновляем графики; пока ставится — следим за ходом установки.
+    useEffect(() => {
+        if (!status?.ready) return;
+        void loadOverview();
+        const t = setInterval(() => { void loadOverview(); }, 15000);
+        return () => clearInterval(t);
+    }, [status?.ready, loadOverview]);
+
+    // Пока идёт установка или удаление — следим за ходом: раз в 2 с читаем статус и лог
+    useEffect(() => {
+        if (!pending && !status?.job?.running) return;
+        const t = setInterval(async () => {
+            const s = await loadStatus();
+            if (s && !s.job?.running) setPending(null);
+        }, 2000);
+        return () => clearInterval(t);
+    }, [pending, status?.job?.running, loadStatus]);
+
+    const run = async (action: 'install' | 'remove') => {
+        if (action === 'remove' && !confirm('Удалить Prometheus? Он будет остановлен, а накопленные графики (до 31 дня) сотрутся. Панель продолжит отдавать /metrics.')) return;
+        setPending(action);
+        try { await apiFetch('POST', `/ui/monitor/${action}`, token); await loadStatus(); }
+        catch (e: any) { setPending(null); showMsg(e?.response?.data?.error ?? (action === 'install' ? 'Не удалось запустить установку' : 'Не удалось запустить удаление')); }
+    };
+    const working = !!pending || !!status?.job?.running;
+
+    // Прогресс рядом с кнопкой: для установки — пока Prometheus нет (там же виден итог удаления), для удаления — только удаление
+    const progressFor = (action: 'install' | 'remove' | 'any') => {
+        const j = status?.job;
+        const mine = !!j && (action === 'any' || j.action === action) && (j.running || j.exit !== null);
+        const starting = !!pending && (action === 'any' || action === pending);
+        return mine || starting ? <JobProgress job={mine ? j! : null} starting={starting} /> : null;
+    };
+
+    // Полный лог — только при ошибке: оператору нужна причина, а не поток строк apt
+    const failureLog = () => {
+        const j = status?.job;
+        if (!j || j.exit === null || j.exit === 0) return null;
+        return (
+            <>
+                <pre className="mon-log">{j.log.trim()}</pre>
+                <p className="login-error">
+                    {j.action === 'install' ? 'Установка' : 'Удаление'} не удалась. Если дело в правах или пакетах, выполните вручную: <b>{`awg-ctrl monitor ${j.action}`}</b>
+                </p>
+            </>
+        );
+    };
+
+    // ───────── установка ─────────
+    const setup = status && !status.ready && (
+        <section className="mon-card" aria-labelledby="mon-setup">
+            <div className="mon-head">
+                <h3 className="mon-title" id="mon-setup">Мониторинг</h3>
+                <span className="chip chip--offline"><span className="chip-dot" />не подключён</span>
+            </div>
+            <p className="mon-hint">
+                Панель поставит Prometheus на этот сервер и сама подключит его к своим метрикам: основные графики —
+                скорость, устройства онлайн, нагрузка на канал, — появятся здесь через минуту-две. Prometheus слушает
+                только 127.0.0.1, наружу он не открывается.
+            </p>
+
+            {status.can_install ? (
+                <div className="mon-actions">
+                    <button className="btn btn--primary" onClick={() => run('install')} disabled={working}>
+                        {pending === 'install' || (status.job?.running && status.job.action === 'install') ? 'Устанавливаем…' : 'Подключить Prometheus'}
+                    </button>
+                    {progressFor('any')}
+                </div>
+            ) : (
+                <>
+                    <p className="mon-hint">Выполните на сервере от root (у этой панели нет своего awg-ctrl, который мог бы сделать это сам):</p>
+                    <code className="mon-code">{status.command}</code>
+                    <div className="mon-actions">
+                        <button className="btn btn--tonal" onClick={() => copyText(status.command).then(() => showMsg('Команда скопирована'))}>
+                            <IcoCopy /> Скопировать
+                        </button>
+                    </div>
+                </>
+            )}
+
+            {failureLog()}
+        </section>
+    );
+
+    // Удаление: только пока Prometheus есть
+    const manage = status?.ready && (
+        <section className="mon-card" aria-labelledby="mon-manage">
+            <div className="mon-head">
+                <h3 className="mon-title" id="mon-manage">Prometheus</h3>
+                <span className="chip chip--online"><span className="chip-dot" />работает</span>
+            </div>
+            <p className="mon-hint">
+                Стоит на этом сервере и слушает только 127.0.0.1:9090, графики хранит 31 день. Удаление остановит его, снимет
+                пакет и сотрёт накопленные данные.
+            </p>
+            {status.can_install ? (
+                <div className="mon-actions">
+                    <button className="btn btn--danger" onClick={() => run('remove')} disabled={working}>
+                        <IcoTrash /> {pending === 'remove' || (status.job?.running && status.job.action === 'remove') ? 'Удаляем…' : 'Удалить Prometheus'}
+                    </button>
+                    {progressFor('remove')}
+                </div>
+            ) : (
+                <>
+                    <p className="mon-hint">Выполните на сервере от root:</p>
+                    <code className="mon-code">awg-ctrl monitor remove</code>
+                </>
+            )}
+            {status.job?.action === 'remove' && failureLog()}
+        </section>
+    );
+
+    // ───────── дашборд ─────────
+    // Вкладка показывает один сервер — выбранный в сервер-баре; при смене сервера App монтирует её заново.
+    const one  = ov?.servers[0];
+    const data = ov?.total ?? null;
+    const cur  = data && {
+        // Скорость «сейчас» — от сервера: на неделе/месяце последняя точка ряда — среднее за шаг, а не текущее
+        down: one?.down ?? lastOf(data.down), up: one?.up ?? lastOf(data.up), online: lastOf(data.online), heavy: lastOf(data.heavy),
+        busy: !!one?.congested,
+    };
+    const used = one?.used_down != null && one.used_up != null ? one.used_down + one.used_up : null;
+    // Одна единица на всю ось (Мбит/с, а не «50 Мбит» у каждой риски): выбирается по максимуму ряда
+    const peak = data ? Math.max(0, ...data.down.map(p => p[1]), ...data.up.map(p => p[1])) : 0;
+    const unit = peak >= 1e9 ? { name: 'Гбит/с', div: 1e9 } : peak >= 1e6 ? { name: 'Мбит/с', div: 1e6 } : peak >= 1e3 ? { name: 'Кбит/с', div: 1e3 } : { name: 'бит/с', div: 1 };
+    const dashboard = status?.ready && (
+        <>
+            {/* Период — единственный фильтр: он задаёт окно для всего ниже */}
+            <div className="mon-filters" role="group" aria-label="Период">
+                {RANGES.map(([id, label]) => (
+                    <button key={id} type="button" className={`mon-range${range === id ? ' mon-range--on' : ''}`}
+                        aria-pressed={range === id} onClick={() => setRange(id)}>{label}</button>
+                ))}
+            </div>
+
+            {ovErr && <p className="login-error">{ovErr}</p>}
+            {ov && !one?.ok && (
+                <p className="mon-hint mon-notice">Этот сервер сейчас не отдаёт метрики: графики могут быть неполными или пустыми.</p>
+            )}
+
+            <div className="mon-tiles">
+                <div className="mon-tile">
+                    <span className="mon-tile-label">Трафик сейчас</span>
+                    {/* Стрелки окрашены как серии графика «Трафик» ниже */}
+                    <div className="mon-tile-rates">
+                        <span className="mon-tile-value mon-tile-rate">
+                            <span className="mon-tile-dir" style={{ color: 'var(--series-1)' }} role="img" aria-label="загрузка">↓</span>
+                            {cur?.down != null ? rate(cur.down) : '—'}
+                        </span>
+                        <span className="mon-tile-value mon-tile-rate">
+                            <span className="mon-tile-dir" style={{ color: 'var(--series-2)' }} role="img" aria-label="отдача">↑</span>
+                            {cur?.up != null ? rate(cur.up) : '—'}
+                        </span>
+                    </div>
+                    <span className="mon-tile-value mon-tile-rate mon-tile-total">
+                        {used != null ? vol(used) : '—'}
+                        <span className="mon-tile-sub">потрачено за {RANGES.find(([id]) => id === range)?.[1]}</span>
+                    </span>
+                </div>
+                <div className="mon-tile">
+                    <span className="mon-tile-label">Устройства</span>
+                    {/* Точки окрашены как серии графика «Устройства» ниже */}
+                    <div className="mon-tile-rates">
+                        <span className="mon-tile-value mon-tile-rate">
+                            <span className="mon-tile-dot" style={{ background: 'var(--series-1)' }} aria-hidden="true" />
+                            {cur?.online != null ? nf(cur.online, 0) : '—'}
+                            <span className="mon-tile-sub">онлайн</span>
+                        </span>
+                        <span className="mon-tile-value mon-tile-rate">
+                            <span className="mon-tile-dot" style={{ background: 'var(--series-2)' }} aria-hidden="true" />
+                            {cur?.heavy != null ? nf(cur.heavy, 0) : '—'}
+                            <span className="mon-tile-sub">в фоне · {cur?.busy ? 'канал занят' : 'канал свободен'}</span>
+                        </span>
+                    </div>
+                </div>
+                <div className="mon-tile">
+                    <span className="mon-tile-label">Нагрузка</span>
+                    <div className="mon-tile-rates">
+                        <div className="mon-tile-meter">
+                            <span className="mon-tile-value mon-tile-rate">
+                                {one?.cpu != null ? `${nf(one.cpu, 0)} %` : '—'}
+                                <span className="mon-tile-sub">процессор{one?.cores ? ` · ${nf(one.cores, 0)} ядер` : ''}</span>
+                            </span>
+                            <Bar v={one?.cpu} label="Загрузка процессора" />
+                        </div>
+                        <div className="mon-tile-meter">
+                            <span className="mon-tile-value mon-tile-rate">
+                                {one?.mem != null ? `${nf(one.mem, 0)} %` : '—'}
+                                <span className="mon-tile-sub">память{one?.mem_total ? ` · из ${gb(one.mem_total)}` : ''}</span>
+                            </span>
+                            <Bar v={one?.mem} label="Занято оперативной памяти" />
+                        </div>
+                    </div>
+                </div>
+            </div>
+
+            {ov && data && (
+                <div className="mon-charts">
+                    <LineChart title={`Трафик, ${unit.name}`} from={ov.from} to={ov.to} step={ov.step} dim={loading}
+                        format={v => rate(v)} formatAxis={v => nf(v / unit.div, unit.div > 1 && v / unit.div < 10 ? 1 : 0)}
+                        series={[
+                            { id: 'down', name: 'загрузка', color: 'var(--series-1)', points: data.down },
+                            { id: 'up',   name: 'отдача',   color: 'var(--series-2)', points: data.up },
+                        ]} />
+                    <LineChart title="Процессор и память, %" from={ov.from} to={ov.to} step={ov.step} dim={loading} max={100}
+                        format={v => `${nf(v, 0)} %`}
+                        series={[
+                            { id: 'cpu', name: 'процессор', color: 'var(--series-1)', points: data.cpu },
+                            { id: 'mem', name: 'память',    color: 'var(--series-2)', points: data.mem },
+                        ]} />
+                    <LineChart title="Устройства" from={ov.from} to={ov.to} step={ov.step} dim={loading}
+                        format={v => nf(v, 0)}
+                        series={[
+                            { id: 'online', name: 'онлайн', color: 'var(--series-1)', points: data.online },
+                            { id: 'heavy',  name: 'в фоне', color: 'var(--series-2)', points: data.heavy },
+                        ]} />
+                    <LineChart title="Отброшено очередью, пакетов/с" from={ov.from} to={ov.to} step={ov.step} dim={loading}
+                        format={v => nf(v, 1)}
+                        series={[{ id: 'drops', name: 'отброшено', color: 'var(--series-1)', points: data.drops }]} />
+                </div>
+            )}
+        </>
+    );
+
+    return (
+        <>
+            {server && (
+                <p className="mon-server">
+                    <span className="mon-server-label">Сервер</span>
+                    <b>{server.health?.server || server.name}</b>
+                    <span className={`chip chip--${server.online ? 'online' : 'offline'}`}><span className="chip-dot" />{server.online ? 'на связи' : 'нет связи'}</span>
+                </p>
+            )}
+
+            {!status && <p className="mon-hint">Загрузка…</p>}
+            {setup}
+            {dashboard}
+            {manage}
+        </>
+    );
+}

awg-ui/src/tabs/monitor/metadata.json

@@ -0,0 +1,11 @@
+{
+  "id": "monitor",
+  "label": "Монитор",
+  "icon": "pulse",
+  "group": "server",
+  "order": 1.7,
+  "chrome": {
+    "serverBar": false,
+    "restart": false
+  }
+}

awg-ui/src/tabs/monitor/monitor.css

@@ -0,0 +1,148 @@
+/*
+Copyright (c) 2026 Ivan Vasilev
+This source code is licensed under the MIT license found in the
+LICENSE file in the root directory of this source tree.
+*/
+/* Стили вкладки «Монитор». Общая дизайн-система — в App.css. */
+.mon-card {
+    display: flex; flex-direction: column; gap: 12px;
+    background: var(--surface-bright);
+    border: 1px solid var(--outline-variant);
+    border-radius: var(--r-card);
+    padding: 20px;
+    margin-bottom: 16px;
+}
+.mon-head { display: flex; align-items: center; justify-content: space-between; gap: 12px; flex-wrap: wrap; }
+.mon-title { margin: 0; font-size: 16px; font-weight: 500; color: var(--on-surface); }
+.mon-hint { margin: 0; font-size: 12px; color: var(--neutral-text); }
+.mon-actions { display: flex; flex-wrap: wrap; gap: 8px; }
+
+.mon-code {
+    display: block; word-break: break-all; user-select: all;
+    font-family: var(--mono); font-size: 12px; color: var(--on-surface);
+    background: var(--surface-container);
+    border-radius: var(--r-table);
+    padding: 12px;
+}
+
+@media (max-width: 640px) {
+    .mon-actions .btn { flex: 1; }
+}
+
+/* ───── Графики ─────
+   Цвета рядов — токены темы. Проверено validate_palette: светлая #6a45b8 / #c4620a на #fdfaf6,
+   тёмная #8f6be0 / #d9772a на #2b251d (CVD ΔE ≥ 19, контраст ≥ 3:1). Подписи и значения цветом ряда не красим. */
+:root { --series-1: #6a45b8; --series-2: #c4620a; }
+:root[data-theme="dark"] { --series-1: #8f6be0; --series-2: #d9772a; }
+
+.mon-filters { display: flex; flex-wrap: wrap; gap: 8px; margin-bottom: 16px; }
+.mon-range {
+    min-height: 44px; padding: 0 18px;
+    font: inherit; font-size: 14px; color: var(--on-surface);
+    background: var(--surface-bright);
+    border: 1px solid var(--outline); border-radius: var(--r-pill);
+    cursor: pointer;
+}
+.mon-range:hover { background: var(--state-primary); }
+.mon-range--on { background: var(--primary-container); color: var(--on-primary-container); border-color: transparent; font-weight: 500; }
+
+.mon-tiles { display: grid; grid-template-columns: repeat(auto-fit, minmax(148px, 1fr)); gap: 12px; margin-bottom: 16px; }
+.mon-tile {
+    display: flex; flex-direction: column; gap: 4px;
+    background: var(--surface-bright);
+    border: 1px solid var(--outline-variant); border-radius: var(--r-table);
+    padding: 14px 16px;
+}
+.mon-tile-label { font-size: 12px; color: var(--neutral-text); }
+.mon-tile-value { font-size: 20px; font-weight: 500; color: var(--on-surface); }
+.mon-tile-sub   { font-size: 12px; color: var(--neutral-text); }
+.mon-tile-rates { display: flex; flex-direction: column; gap: 10px; margin-top: 8px; }
+.mon-tile-rate  { display: flex; flex-wrap: wrap; align-items: baseline; gap: 2px 8px; white-space: nowrap; }
+.mon-tile-dir   { font-size: 16px; }
+.mon-tile-total { margin-top: 6px; padding-top: 10px; border-top: 1px solid var(--outline-variant); }
+.mon-tile-meter { display: flex; flex-direction: column; gap: 4px; }
+.mon-tile-dot   { width: 8px; height: 8px; border-radius: 50%; flex: none; align-self: center; }
+
+.mon-charts { display: grid; grid-template-columns: 1fr; gap: 16px; margin-bottom: 16px; }
+@media (min-width: 1000px) {
+    .mon-charts { grid-template-columns: 1fr 1fr; }
+    .mon-charts .mon-chart:first-child { grid-column: 1 / -1; }
+}
+.mon-chart {
+    margin: 0; min-width: 0;
+    background: var(--surface-bright);
+    border: 1px solid var(--outline-variant); border-radius: var(--r-card);
+    padding: 16px;
+    transition: opacity .15s;
+}
+.mon-chart--dim { opacity: .6; }
+.mon-chart-head { display: flex; align-items: center; flex-wrap: wrap; gap: 4px 16px; margin-bottom: 4px; }
+.mon-chart-title { font-size: 15px; font-weight: 500; color: var(--on-surface); }
+.mon-legend { display: flex; flex-wrap: wrap; gap: 4px 14px; font-size: 12px; color: var(--neutral-text); }
+.mon-legend-item { display: inline-flex; align-items: center; gap: 6px; }
+.mon-key { display: inline-block; width: 14px; height: 3px; border-radius: 2px; flex: none; }
+.mon-chart-toggle {
+    margin-left: auto; min-height: 44px; padding: 0 12px;
+    font: inherit; font-size: 13px; color: var(--on-primary-container);
+    background: none; border: 0; border-radius: var(--r-pill); cursor: pointer;
+}
+.mon-chart-toggle:hover { background: var(--state-primary); }
+
+.mon-plot { position: relative; }
+.mon-plot svg { display: block; max-width: 100%; }
+.mon-plot svg:focus-visible { outline: 2px solid var(--primary); outline-offset: 2px; border-radius: 8px; }
+.mon-grid  { stroke: var(--outline-variant); stroke-width: 1; }
+.mon-tick  { fill: var(--neutral-text); font-size: 12px; font-family: var(--font); }
+.mon-cross { stroke: var(--outline); stroke-width: 1; }
+.mon-end   { stroke: var(--surface-bright); stroke-width: 2px; }
+.mon-empty { position: absolute; inset: 0; display: flex; align-items: center; justify-content: center; padding: 0 24px; text-align: center; font-size: 13px; color: var(--neutral-text); }
+.mon-tip {
+    position: absolute; pointer-events: none; z-index: 2;
+    display: flex; flex-direction: column; gap: 4px;
+    background: var(--surface-container);
+    border: 1px solid var(--outline-variant); border-radius: 12px;
+    padding: 8px 10px; font-size: 12px; color: var(--neutral-text);
+}
+.mon-tip-time { color: var(--neutral-text); }
+.mon-tip-row { display: flex; align-items: center; gap: 8px; }
+.mon-tip-row b { font-weight: 500; font-size: 13px; color: var(--on-surface); }
+
+.mon-table-wrap { overflow-x: auto; }
+.mon-table { width: 100%; border-collapse: collapse; font-size: 13px; }
+.mon-table th { text-align: left; font-weight: 500; color: var(--label); padding: 8px 10px; white-space: nowrap; }
+.mon-table td { padding: 8px 10px; color: var(--on-surface); border-top: .5px solid var(--outline-variant); font-variant-numeric: tabular-nums; white-space: nowrap; }
+
+.mon-log {
+    margin: 0; max-height: 240px; overflow: auto;
+    font-family: var(--mono); font-size: 12px; color: var(--on-surface);
+    background: var(--surface-container); border-radius: var(--r-table);
+    padding: 12px; white-space: pre-wrap; word-break: break-word;
+}
+
+.mon-notice { margin-bottom: 12px; }
+
+/* Полоски процессора и памяти в плитках */
+.mon-bar { display: block; width: 100%; height: 8px; border-radius: 4px; overflow: hidden; background: var(--primary-container); margin: 2px 0; }
+.mon-bar i { display: block; height: 100%; border-radius: 4px; background: var(--series-1); transition: width .3s; }
+.mon-bar i.mon-bar--warn { background: var(--warn-dot); }
+.mon-bar i.mon-bar--bad  { background: var(--error-dot); }
+
+/* Какой сервер показан (выбирается в других вкладках) */
+.mon-server { display: flex; align-items: center; flex-wrap: wrap; gap: 8px 12px; margin: 0 0 12px; font-size: 16px; color: var(--on-surface); }
+.mon-server b { font-weight: 500; }
+.mon-server-label { font-size: 12px; color: var(--neutral-text); }
+
+
+/* Прогресс операции рядом с кнопкой */
+.mon-actions { align-items: center; }
+.mon-progress { flex: 1; min-width: 200px; display: flex; flex-direction: column; gap: 6px; }
+.mon-progress-label { font-size: 12px; color: var(--neutral-text); }
+.mon-pbar { display: block; width: 100%; height: 8px; border-radius: 4px; overflow: hidden; background: var(--primary-container); }
+.mon-pbar i { display: block; height: 100%; border-radius: 4px; background: var(--series-1); transition: width .4s ease; }
+.mon-pbar--ok i  { background: var(--success-dot); }
+.mon-pbar--bad i { background: var(--error-dot); }
+/* Шага ещё нет — ход неизвестен: бегущий отрезок вместо ложных процентов */
+.mon-pbar--wait i { width: 35% !important; animation: mon-wait 1.2s ease-in-out infinite; }
+@keyframes mon-wait { 0% { transform: translateX(-100%); } 100% { transform: translateX(290%); } }
+@media (prefers-reduced-motion: reduce) { .mon-pbar--wait i { animation: none; } .mon-pbar i { transition: none; } }
+

awg-ui/src/tabs/users/index.tsx

@@ -8,6 +8,8 @@ import {
     type User, type PageProps, type AwgGen,
 } from '../../lib/shared';
 import { IcoPlus, IcoRefresh, IcoQR, IcoTrash, IcoGlobe } from '../../components/icons';
+import PriorityChip from '../../components/PriorityChip';
+import TorrentChip from '../../components/TorrentChip';
 import './users.css';
 
 // Вкладка «Пользователи»: форма создания + таблица (десктоп) / карточки (мобильный)
@@ -28,7 +30,7 @@ export default function UsersPage({ token, showMsg }: PageProps) {
             const data = await apiFetch('GET', '/api/users/stats', tok);
             setUsers(prev => prev.map(u => {
                 const s = (data.users as User[] ?? []).find(x => x.name === u.name);
-                return s ? { ...u, online: s.online, lastHandshake: s.lastHandshake, rx: s.rx, tx: s.tx } : u;
+                return s ? { ...u, online: s.online, lastHandshake: s.lastHandshake, rx: s.rx, tx: s.tx, priority: s.priority, torrent: s.torrent } : u;
             }));
         } catch { /* silent */ }
     }, []);
@@ -162,6 +164,7 @@ export default function UsersPage({ token, showMsg }: PageProps) {
                         <tr>
                             <th>#</th>
                             <th>Статус</th>
+                            <th>Приоритет</th>
                             <th>Имя</th>
                             <th>IP</th>
                             <th>↓ rx</th>
@@ -171,7 +174,7 @@ export default function UsersPage({ token, showMsg }: PageProps) {
                     </thead>
                     <tbody>
                         {users.length === 0 ? (
-                            <tr><td colSpan={7} className="empty">Нет пользователей</td></tr>
+                            <tr><td colSpan={8} className="empty">Нет пользователей</td></tr>
                         ) : users.map((u, i) => (
                             <tr key={u.name}>
                                 <td className="td-num">{i + 1}</td>
@@ -185,6 +188,7 @@ export default function UsersPage({ token, showMsg }: PageProps) {
                                                 : 'никогда'}
                                     </span>
                                 </td>
+                                <td><span className="user-chips"><PriorityChip priority={u.priority} torrent={u.torrent} /><TorrentChip torrent={u.torrent} /></span></td>
                                 <td>
                                     {u.name}
                                     {u.key_gen !== serverGen && (
@@ -251,6 +255,8 @@ export default function UsersPage({ token, showMsg }: PageProps) {
                         <div className="user-card-ip">
                             <IcoGlobe />
                             <span className="user-card-ip-text">{u.ip}</span>
+                            <PriorityChip priority={u.priority} torrent={u.torrent} />
+                            <TorrentChip torrent={u.torrent} />
                         </div>
                         <div className="user-card-metrics">
                             <div className="metric-block">

awg-ui/src/tabs/users/metadata.json

@@ -2,5 +2,6 @@
   "id": "users",
   "label": "Пользователи",
   "icon": "users",
+  "group": "main",
   "order": 1
 }

awg-ui/src/tabs/users/users.css

@@ -47,6 +47,7 @@ LICENSE file in the root directory of this source tree.
 }
 .user-card-ip {
     display: flex;
+    flex-wrap: wrap;
     align-items: center;
     gap: 8px;
     color: var(--neutral-text);
@@ -78,3 +79,6 @@ LICENSE file in the root directory of this source tree.
     /* .tip-wrap на мобильной растягивается на всю ширину — метке это не нужно. */
     .user-gen { width: auto; }
 }
+
+/* Чипы приоритета и торрентов в одной ячейке */
+.user-chips { display: inline-flex; flex-wrap: wrap; gap: 6px; }

awg-ui/sub.ts

@@ -72,6 +72,8 @@ const TS_WINDOW    = 300;           // секунд, ±
 const DEFAULT_LIMIT = 3;
 const MAX_SERVERS   = 32;           // серверов в одном мастер-ключе
 const SYNC_EVERY    = 60_000;       // фоновое сведение серверов
+const AUDIT_HOUR    = 3_600_000;
+const AUDIT_FIRST   = 120_000;      // первый аудит — вскоре после старта, когда ноды подключились
 const B64_PUB       = /^[A-Za-z0-9+/]{43}=$/;
 const CLIENT_VERSION = /^[\w.+-]{1,32}$/;   // версия приложения, чисто информационная
 
@@ -407,6 +409,161 @@ export function createSub(deps: { uidb: Database.Database; servers: Servers; bas
         q.revokedGone.run();
     }
 
+    // ── Аудит серверов ─────────────────────────────────────────────────────
+    // Периодически (по умолчанию раз в час) core обходит все серверы и ищет «мёртвых»: пиров, которые живы на сервере, хотя
+    // панель про них не знает. Сообщает и — если включена очистка (настройки аудита) или оператор нажал кнопку — снимает подтверждённых: мёртвых два прохода подряд.
+    //   ghosts  — есть в ядре (awg show), но неизвестны awg-ctrl: строку удалили, а `awg set … remove`
+    //             не сработал, и никто про такого пира уже не вспомнит;
+    //   orphans — есть у awg-ctrl в области этой панели, но панели не нужны (sync их не снял);
+    //             key — мастер-ключ пира, если он отозван или удалён.
+    // Пиры чужой области (другая панель, пиры до областей) в отчёт не попадают — считаются в foreign.
+    // seen_before — «мёртвый» и в прошлом проходе тоже: только такие снимает очистка (пир, которого
+    // прямо сейчас добавляют или удаляют, за два прохода подряд мёртвым не окажется).
+    interface AuditPeer { pub_key: string; owner?: string; key?: string | null; online: boolean; lastHandshake: number; seen_before?: boolean }
+    interface AuditEntry {
+        server_id: number; status: "ok" | "offline" | "error";
+        ghosts_checked: boolean;        // false — awg-ctrl старше /api/audit, «призраков» не видно
+        ghosts: AuditPeer[]; orphans: AuditPeer[]; foreign: number;
+        blocked?: number;               // очистка отказалась снимать столько пиров разом (предохранитель)
+    }
+    interface AuditReport { at: number; servers: AuditEntry[] }
+    interface CleanedPeer { at: number; server_id: number; pub_key: string; kind: "ghost" | "orphan"; key?: string | null; auto: boolean }
+    // Настройки аудита (панель, вкладка «Аудит»). clean — снимать «мёртвых» сами; every_h — период;
+    // max — предохранитель: больше пиров на сервере за проход не снимаем, только сообщаем.
+    interface AuditSettings { clean: boolean; every_h: number; max: number }
+    const AUDIT_DEFAULTS: AuditSettings = { clean: false, every_h: 1, max: 10 };
+
+    const AUDIT_ON = (process.env.AUDIT ?? "on").toLowerCase() !== "off";   // выключен у ноды со своей панелью
+    const metaGet = <T,>(key: string, dflt: T): T => {
+        try {
+            const row = uidb.prepare("SELECT value FROM sub_meta WHERE key = ?").get(key) as { value: string } | undefined;
+            return row ? JSON.parse(row.value) as T : dflt;
+        } catch { return dflt; }
+    };
+    const metaSet = (key: string, v: unknown) =>
+        uidb.prepare("INSERT INTO sub_meta (key, value) VALUES (?, ?) ON CONFLICT(key) DO UPDATE SET value = excluded.value").run(key, JSON.stringify(v));
+    let lastAudit: AuditReport | null = metaGet<AuditReport | null>("audit", null);
+    let auditSettings: AuditSettings = { ...AUDIT_DEFAULTS, ...metaGet<Partial<AuditSettings>>("audit_settings", {}) };
+    let cleanedLog: CleanedPeer[] = metaGet<CleanedPeer[]>("audit_cleaned", []);
+
+    async function auditNow(id: number): Promise<AuditEntry> {
+        const entry: AuditEntry = { server_id: id, status: "ok", ghosts_checked: true, ghosts: [], orphans: [], foreign: 0 };
+        if (!servers.exists(id) || !servers.isOnline(id)) return { ...entry, status: "offline", ghosts_checked: false };
+        const ctrl = servers.ctrlFor(id);
+        // Сначала обычное сведение: отчёт — про то, что не снялось само.
+        await reconcileNow(id);
+        const [a, p] = [await ctrl("GET", "/api/audit"), await ctrl("GET", "/api/peers")];
+        if (!hasCtrlOk(p.status)) return { ...entry, status: "error", ghosts_checked: false };
+        if (hasCtrlOk(a.status)) entry.ghosts = (a.data.ghosts as AuditPeer[]).map(g => ({
+            pub_key: g.pub_key, online: g.online, lastHandshake: g.lastHandshake,
+        }));
+        else if (a.status === 404) entry.ghosts_checked = false;
+        else return { ...entry, status: "error", ghosts_checked: false };
+
+        const keep = new Set((q.keepOf.all(id, id) as { pub: string }[]).map(r => r.pub));
+        const prefix = panelId + "/";
+        for (const peer of p.data.peers as { pub_key: string; owner: string; online: boolean; lastHandshake: number }[]) {
+            if (!peer.owner.startsWith(prefix)) { if (peer.owner.includes("/")) entry.foreign++; continue; }
+            if (keep.has(peer.pub_key)) continue;
+            const mid = Number(peer.owner.match(/^[^/]+\/m(\d+)\//)?.[1]);
+            const m = Number.isSafeInteger(mid) ? q.masterRow.get(mid) as MasterRow | undefined : undefined;
+            entry.orphans.push({
+                pub_key: peer.pub_key, owner: peer.owner, online: peer.online, lastHandshake: peer.lastHandshake,
+                key: m ? (m.revoked_at !== null ? `${m.label} (удалён)` : m.label) : "(нет в ui.db)",
+            });
+        }
+        return entry;
+    }
+
+    // Под той же блокировкой, что и сведение: пир, которого прямо сейчас добавляет проход, не «призрак».
+    function audit(id: number): Promise<AuditEntry> {
+        const run = (locks.get(id) ?? Promise.resolve()).then(() => auditNow(id));
+        locks.set(id, run.then(() => {}, () => {}));
+        return run.catch((): AuditEntry => ({ server_id: id, status: "error", ghosts_checked: false, ghosts: [], orphans: [], foreign: 0 }));
+    }
+
+    // Снять «мёртвых» этого сервера: только подтверждённых (seen_before), не больше max за проход.
+    // «Призраки» — через awg-ctrl (он сам перепроверяет ключи), лишние — обычным DELETE.
+    async function cleanEntry(e: AuditEntry, auto: boolean): Promise<void> {
+        const ghosts  = e.ghosts.filter(p => p.seen_before);
+        const orphans = e.orphans.filter(p => p.seen_before);
+        if (ghosts.length + orphans.length === 0 || e.status !== "ok") return;
+        if (auto && ghosts.length + orphans.length > auditSettings.max) {
+            e.blocked = ghosts.length + orphans.length;
+            console.warn(`sub: очистка сервера #${e.server_id} пропущена: ${e.blocked} пиров больше предела ${auditSettings.max}`);
+            return;
+        }
+        const ctrl = servers.ctrlFor(e.server_id);
+        const done: CleanedPeer[] = [];
+        const log = (p: AuditPeer, kind: CleanedPeer["kind"]) =>
+            done.push({ at: now(), server_id: e.server_id, pub_key: p.pub_key, kind, key: p.key, auto });
+        if (ghosts.length) {
+            const r = await ctrl("POST", "/api/audit/clean", { pub_keys: ghosts.map(g => g.pub_key) });
+            if (hasCtrlOk(r.status)) {
+                const gone = new Set(r.data.removed as string[]);
+                for (const g of ghosts) if (gone.has(g.pub_key)) log(g, "ghost");
+            }
+        }
+        for (const p of orphans) {
+            const r = await ctrl("DELETE", `/api/peers/${pubParam(p.pub_key)}`);
+            if (hasCtrlOk(r.status) || r.status === 404) log(p, "orphan");
+            else if (gone502(r.status)) break;
+        }
+        if (!done.length) return;
+        const cleaned = new Set(done.map(d => d.pub_key));
+        e.ghosts  = e.ghosts.filter(p => !cleaned.has(p.pub_key));
+        e.orphans = e.orphans.filter(p => !cleaned.has(p.pub_key));
+        cleanedLog = [...done, ...cleanedLog].slice(0, 100);
+        metaSet("audit_cleaned", cleanedLog);
+        console.warn(`sub: ${auto ? "автоочистка" : "очистка"} сервера #${e.server_id}: снято ${done.length} (${done.map(d => d.pub_key.slice(0, 8)).join(", ")})`);
+    }
+    const gone502 = (s: number) => s === 502 || s === 504;
+
+    let auditing: Promise<AuditReport> | null = null;
+    // auto — плановый проход: очищает сам, если включено. Ручной только смотрит и обновляет «видели раньше».
+    function auditAll(auto = false): Promise<AuditReport> {
+        auditing ??= (async () => {
+            const prev = lastAudit;
+            const report: AuditReport = { at: now(), servers: await Promise.all(servers.ids().map(audit)) };
+            for (const e of report.servers) {
+                const before = prev?.servers.find(x => x.server_id === e.server_id);
+                const was = new Set([...(before?.ghosts ?? []), ...(before?.orphans ?? [])].map(p => p.pub_key));
+                for (const p of [...e.ghosts, ...e.orphans]) p.seen_before = was.has(p.pub_key);
+                if (auto && auditSettings.clean) await audit_clean(e);
+            }
+            lastAudit = report;
+            metaSet("audit", report);
+            for (const e of report.servers) {
+                if (e.status === "error") console.warn(`sub: аудит сервера #${e.server_id} не удался`);
+                if (e.ghosts.length || e.orphans.length)
+                    console.warn(`sub: аудит сервера #${e.server_id}: мёртвых пиров ${e.ghosts.length + e.orphans.length} ` +
+                        `(в ядре без записи: ${e.ghosts.length}, лишних у awg-ctrl: ${e.orphans.length}, онлайн: ` +
+                        `${[...e.ghosts, ...e.orphans].filter(x => x.online).length})`);
+            }
+            return report;
+        })().finally(() => { auditing = null; });
+        return auditing;
+    }
+    // Очистка под блокировкой сервера — как и сам аудит.
+    function audit_clean(e: AuditEntry): Promise<void> {
+        const run = (locks.get(e.server_id) ?? Promise.resolve()).then(() => cleanEntry(e, true));
+        locks.set(e.server_id, run.then(() => {}, () => {}));
+        return run.catch(err => { console.warn(`sub: очистка сервера #${e.server_id} не удалась: ${(err as Error).message}`); });
+    }
+
+    // Ручная очистка подтверждённых «мёртвых» по последнему отчёту (кнопка на вкладке «Аудит»).
+    async function cleanNow(): Promise<AuditReport | null> {
+        if (!lastAudit) return null;
+        for (const e of lastAudit.servers) {
+            const run = (locks.get(e.server_id) ?? Promise.resolve()).then(() => cleanEntry(e, false));
+            locks.set(e.server_id, run.then(() => {}, () => {}));
+            await run.catch(() => {});
+        }
+        metaSet("audit", lastAudit);
+        return lastAudit;
+    }
+    const auditState = () => ({ enabled: AUDIT_ON, settings: auditSettings, report: lastAudit, cleaned: cleanedLog });
+
     /** Устройство удаляется: его пиров — в список на удаление, строку — из реестра. */
     function forgetDevice(dev: DeviceRow): number[] {
         const links = q.linksOf.all(dev.id) as LinkRow[];
@@ -834,15 +991,17 @@ export function createSub(deps: { uidb: Database.Database; servers: Servers; bas
     // Статистика устройства — по всем серверам ключа: онлайн, если есть свежий handshake хоть
     // на одном; трафик суммируется. servers_ok — на скольких серверах уже стоит его текущий ключ.
     async function masterDevices(m: MasterRow) {
-        const stats = new Map<string, { online: boolean; lastHandshake: number; rx: number; tx: number }>();
+        const stats = new Map<string, { online: boolean; lastHandshake: number; rx: number; tx: number; background: boolean }>();
         await Promise.all(serverIdsOf(m.id).filter(id => servers.isOnline(id)).map(async id => {
             const r = await servers.ctrlFor(id)("GET", "/api/peers");
             if (!hasCtrlOk(r.status)) return;
-            for (const p of r.data.peers as { pub_key: string; online: boolean; lastHandshake: number; rx: number; tx: number }[]) {
-                const s = stats.get(p.pub_key) ?? { online: false, lastHandshake: 0, rx: 0, tx: 0 };
+            for (const p of r.data.peers as { pub_key: string; online: boolean; lastHandshake: number; rx: number; tx: number; priority?: string }[]) {
+                const s = stats.get(p.pub_key) ?? { online: false, lastHandshake: 0, rx: 0, tx: 0, background: false };
                 stats.set(p.pub_key, {
                     online: s.online || p.online, lastHandshake: Math.max(s.lastHandshake, p.lastHandshake),
                     rx: s.rx + p.rx, tx: s.tx + p.tx,
+                    // Устройство стоит на каждом сервере со своим IP; фоновым его делает любой из них.
+                    background: s.background || p.priority === "background",
                 });
             }
         }));
@@ -853,6 +1012,7 @@ export function createSub(deps: { uidb: Database.Database; servers: Servers; bas
                 id: d.id, device_id: d.device_id, device_name: d.device_name, platform: d.platform, version: d.version, created_at: d.created_at,
                 last_seen: d.last_seen, rekey_requested: d.rekey_requested === 1,
                 online: s?.online ?? false, lastHandshake: s?.lastHandshake ?? 0, rx: s?.rx ?? 0, tx: s?.tx ?? 0,
+                priority: s?.background ? "background" : "normal",
                 servers_total: links.length, servers_ok: links.filter(l => l.peer_pub === d.pub_key && l.ip).length,
             };
         });
@@ -876,6 +1036,35 @@ export function createSub(deps: { uidb: Database.Database; servers: Servers; bas
     masterKeys.get("/", (_req, res) => {
         res.json({ enabled: signKey !== null, tls: tlsPin !== null, keys: listMasters(null) });
     });
+    // Аудит серверов (только core): отчёт, внеочередной проход, ручная очистка, настройки.
+    masterKeys.get("/audit", (_req, res) => { res.json(auditState()); });
+    masterKeys.post("/audit", aw(async (_req, res) => {
+        if (!AUDIT_ON) fail(409, "Аудит выключен на этой панели");
+        await auditAll();
+        res.json(auditState());
+    }));
+    masterKeys.post("/audit/clean", aw(async (_req, res) => {
+        if (!AUDIT_ON) fail(409, "Аудит выключен на этой панели");
+        await cleanNow();
+        res.json(auditState());
+    }));
+    masterKeys.put("/audit/settings", aw((req, res) => {
+        if (!AUDIT_ON) fail(409, "Аудит выключен на этой панели");
+        const b = (req.body ?? {}) as Partial<AuditSettings>;
+        const next = { ...auditSettings };
+        if (b.clean !== undefined) { if (typeof b.clean !== "boolean") fail(400, "clean: true или false"); next.clean = b.clean; }
+        if (b.every_h !== undefined) {
+            if (!Number.isInteger(b.every_h) || b.every_h < 1 || b.every_h > 168) fail(400, "Период: от 1 до 168 часов");
+            next.every_h = b.every_h;
+        }
+        if (b.max !== undefined) {
+            if (!Number.isInteger(b.max) || b.max < 1 || b.max > 1000) fail(400, "Предел: от 1 до 1000");
+            next.max = b.max;
+        }
+        auditSettings = next;
+        metaSet("audit_settings", next);
+        res.json(auditState());
+    }));
     masterKeys.post("/", aw((req, res) => { res.status(201).json(createMaster(req.body, null)); }));
     masterKeys.patch("/:id", aw(async (req, res) => { res.json(await updateMaster(masterFor(masterIdOf(req.params.id), null), req.body, null)); }));
     masterKeys.post("/:id/rotate", aw((req, res) => { const m = masterFor(masterIdOf(req.params.id), null); rotateMaster(m); res.json({ id: m.id }); }));
@@ -955,6 +1144,15 @@ export function createSub(deps: { uidb: Database.Database; servers: Servers; bas
             void reconcileAll((q.usedServers.all() as { server_id: number }[]).map(r => r.server_id));
         }, SYNC_EVERY).unref();
 
+        if (AUDIT_ON) {
+            // Период читается из настроек каждый раз: смена в панели действует без рестарта.
+            const next = (ms: number) => setTimeout(() => {
+                auditAll(true).catch(e => console.warn(`sub: аудит не удался: ${(e as Error).message}`))
+                    .finally(() => next(auditSettings.every_h * AUDIT_HOUR));
+            }, ms).unref();
+            next(AUDIT_FIRST);
+        }
+
         if (!signKey) return;
         if (!SUB_PORT) { console.warn("sub: SUB_PORT не задан — подписка отключена"); signKey = null; return; }
         const server = tlsMaterial ? https.createServer(tlsMaterial, sub) : http.createServer(sub);

cli/package.json

@@ -1,6 +1,6 @@
 {
   "name": "awg-cli",
-  "version": "0.3.4",
+  "version": "0.4.3",
   "private": true,
   "dependencies": {
     "tsx": "^4.7.0",

cli/src/index.ts

@@ -9,6 +9,7 @@ import * as readline                            from "readline";
 import * as crypto                              from "crypto";
 import * as http                                from "http";
 import path                                     from "path";
+import { monitorCmd }                           from "./monitor";
 
 const ROOT = path.resolve(__dirname, "../..");
 const LOGS = path.join(ROOT, "logs");
@@ -107,6 +108,10 @@ const SERVICES = {
             // join-строки, живёт как sub_tls.*). Без NODE_PORT хаб выключен. LOCAL_NODE=off —
             // core без собственного VPN: awg-ctrl рядом не нужен.
             NODE_PORT:          process.env.NODE_PORT          ?? "",
+            // Часовой аудит «мёртвых» пиров на всех серверах — только у core (у ноды со своей панелью выключен).
+            AUDIT:              process.env.CORE_HOST ? "off" : (process.env.AUDIT ?? "on"),
+            // Пер-пировые серии в /metrics: только по явному согласию оператора (cli.env).
+            METRICS_PEERS:      process.env.METRICS_PEERS ?? "off",
             LOCAL_NODE:         process.env.LOCAL_NODE         ?? "on",
             NODE_TLS_KEY_FILE:  process.env.NODE_TLS_KEY_FILE  ?? "/etc/amnezia/amneziawg/node_tls.key",
             NODE_TLS_CERT_FILE: process.env.NODE_TLS_CERT_FILE ?? "/etc/amnezia/amneziawg/node_tls.crt",
@@ -640,7 +645,7 @@ async function main() {
         return;
     }
 
-    const USAGE = "Usage: cli <start|stop|restart|status|credentials [user|pass]|join <awgjoin://…> [--no-panel]|unjoin|peers [drop <область>]>";
+    const USAGE = "Usage: cli <start|stop|restart|status|credentials [user|pass]|join <awgjoin://…> [--no-panel]|unjoin|peers [drop <область>]|monitor <install|status|remove>>";
 
     const [,,, sub, arg] = process.argv;
 
@@ -657,6 +662,7 @@ async function main() {
         case "join":        await joinCore(sub, arg);                          break;
         case "unjoin":      await unjoinCore();                                break;
         case "peers":       await peersCmd(sub, arg);                          break;
+        case "monitor":     await monitorCmd(sub);                             break;
         default: console.log(USAGE); process.exit(1);
     }
 }

cli/src/monitor.ts

@@ -0,0 +1,170 @@
+// Copyright (c) 2026 Ivan Vasilev
+// This source code is licensed under the MIT license found in the
+// LICENSE file in the root directory of this source tree.
+//
+// `awg-ctrl monitor install|status|remove` — встроенный Prometheus для вкладки «Монитор».
+// Работает от root (ставит пакет, пишет в /etc): панель сама пакетов не ставит, она только просит
+// (через awg-ctrl) или показывает эту команду. Всё слушает 127.0.0.1: наружу Prometheus не торчит,
+// а панель читает его по HTTP на той же машине.
+import { spawnSync }                                         from "child_process";
+import { readFileSync, writeFileSync, existsSync, copyFileSync, unlinkSync } from "fs";
+import * as crypto                                           from "crypto";
+import * as http                                             from "http";
+
+const AWG_DIR   = "/etc/amnezia/amneziawg";
+const PROM_DIR  = "/etc/prometheus";
+const CONF_FILE = `${PROM_DIR}/prometheus.yml`;
+const TOKEN_FILE = `${PROM_DIR}/forgetting.token`;
+// Хэш локального токена для awg-ui: читает его при проверке /metrics (сам токен знает только Prometheus).
+export const MONITOR_HASH_FILE = `${AWG_DIR}/monitor_token.sha256`;
+const DEFAULTS_FILE = "/etc/default/prometheus";
+const MARKER  = "# managed by forgetting";
+const LISTEN  = "127.0.0.1:9090";
+const RETENTION = "31d";   // с запасом на вид «30 дней» во вкладке «Монитор»
+
+const log  = (s: string) => console.log(`  ${s}`);
+function fail(s: string): never { console.error(`\n  ✗ ${s}\n`); process.exit(1); }
+
+function sh(cmd: string, args: string[], opts: { quiet?: boolean } = {}) {
+    return spawnSync(cmd, args, {
+        encoding: "utf8",
+        stdio: opts.quiet ? ["ignore", "pipe", "pipe"] : ["ignore", "inherit", "inherit"],
+        env: { ...process.env, DEBIAN_FRONTEND: "noninteractive" },
+    });
+}
+
+function osFamily(): string {
+    try {
+        const t = readFileSync("/etc/os-release", "utf8");
+        const id   = t.match(/^ID=(.*)$/m)?.[1]?.replace(/"/g, "") ?? "";
+        const like = t.match(/^ID_LIKE=(.*)$/m)?.[1]?.replace(/"/g, "") ?? "";
+        return `${id} ${like}`;
+    } catch { return ""; }
+}
+
+function ready(timeoutMs = 1500): Promise<boolean> {
+    return new Promise(resolve => {
+        const [host, port] = LISTEN.split(":");
+        const req = http.get({ host, port: Number(port), path: "/-/ready", timeout: timeoutMs }, res => {
+            res.resume(); resolve(res.statusCode === 200);
+        });
+        req.on("timeout", () => { req.destroy(); resolve(false); });
+        req.on("error", () => resolve(false));
+    });
+}
+
+const installed = () => sh("dpkg", ["-s", "prometheus"], { quiet: true }).status === 0;
+const active    = () => sh("systemctl", ["is-active", "--quiet", "prometheus"], { quiet: true }).status === 0;
+const managed   = () => existsSync(CONF_FILE) && readFileSync(CONF_FILE, "utf8").includes(MARKER);
+
+// Новые схемы (authorization.credentials_file) есть с 2.26; в 3.x bearer_token_file убран.
+function authBlock(): string {
+    const v = sh("prometheus", ["--version"], { quiet: true });
+    const m = `${v.stdout ?? ""}${v.stderr ?? ""}`.match(/version (\d+)\.(\d+)/);
+    const [maj, min] = m ? [Number(m[1]), Number(m[2])] : [2, 0];
+    return maj > 2 || (maj === 2 && min >= 26)
+        ? `    authorization:\n      credentials_file: ${TOKEN_FILE}\n`
+        : `    bearer_token_file: ${TOKEN_FILE}\n`;
+}
+
+function writeConfig(uiPort: string) {
+    if (existsSync(CONF_FILE)) copyFileSync(CONF_FILE, `${CONF_FILE}.bak-${new Date().toISOString().replace(/[:.]/g, "-")}`);
+    writeFileSync(CONF_FILE, `${MARKER}
+global:
+  scrape_interval: 15s
+  evaluation_interval: 15s
+
+scrape_configs:
+  - job_name: forgetting
+    scheme: http
+    metrics_path: /metrics
+${authBlock()}    static_configs:
+      - targets: ['127.0.0.1:${uiPort}']
+`, { mode: 0o644 });
+}
+
+// Токен для самого Prometheus. Файл читает пользователь prometheus, в панели лежит только хэш.
+function writeToken() {
+    const token = "awgm_" + crypto.randomBytes(24).toString("base64url");
+    writeFileSync(TOKEN_FILE, token, { mode: 0o640 });
+    sh("chown", ["root:prometheus", TOKEN_FILE], { quiet: true });
+    writeFileSync(MONITOR_HASH_FILE, crypto.createHash("sha256").update(token).digest("hex") + "\n", { mode: 0o644 });
+}
+
+function setArgs() {
+    const line = `ARGS="--web.listen-address=${LISTEN} --storage.tsdb.retention.time=${RETENTION}"`;
+    let text = existsSync(DEFAULTS_FILE) ? readFileSync(DEFAULTS_FILE, "utf8") : "";
+    if (text) copyFileSync(DEFAULTS_FILE, `${DEFAULTS_FILE}.bak-${new Date().toISOString().replace(/[:.]/g, "-")}`);
+    text = /^ARGS=/m.test(text) ? text.replace(/^ARGS=.*$/m, line) : `${text.replace(/\n?$/, "\n")}${line}\n`;
+    writeFileSync(DEFAULTS_FILE, text, { mode: 0o644 });
+}
+
+async function install() {
+    if (process.getuid?.() !== 0) fail("Нужен root: sudo awg-ctrl monitor install");
+    if (!/debian|ubuntu/i.test(osFamily())) fail("Автоустановка поддерживает только Debian и Ubuntu. На другом дистрибутиве поставьте Prometheus сами и подключите его кнопкой в панели (токен метрик).");
+    const uiPort = process.env.UI_PORT;
+    if (!uiPort) fail("На этой машине нет панели (UI_PORT не задан): Prometheus скрейпит метрики панели.");
+
+    // Чужой Prometheus не трогаем: перезаписать его prometheus.yml значит сломать чужой мониторинг.
+    if (installed() && existsSync(CONF_FILE) && !managed()) {
+        fail(`Prometheus уже установлен и настроен не нами (${CONF_FILE}). Подключите его кнопкой «Подключить Prometheus» во вкладке «Монитор»: она выдаст токен и готовый конфиг.`);
+    }
+
+    log("1/4  установка пакета prometheus");
+    if (!installed()) {
+        if (sh("apt-get", ["update", "-qq"]).status !== 0) fail("apt-get update завершился ошибкой");
+        if (sh("apt-get", ["install", "-y", "--no-install-recommends", "prometheus"]).status !== 0) fail("apt-get install prometheus завершился ошибкой");
+    } else log("уже установлен");
+
+    log("2/4  токен и конфиг");
+    writeToken();
+    writeConfig(uiPort);
+
+    log(`3/4  слушаем только ${LISTEN}, хранение ${RETENTION}`);
+    setArgs();
+
+    log("4/4  запуск");
+    sh("systemctl", ["enable", "prometheus"], { quiet: true });
+    if (sh("systemctl", ["restart", "prometheus"]).status !== 0) fail("prometheus не запустился: journalctl -u prometheus");
+    for (let i = 0; i < 30; i++) {
+        if (await ready()) { console.log(`\n  ✓ Prometheus работает на ${LISTEN}, метрики панели скрейпятся каждые 15 с.\n    Во вкладке «Монитор» графики появятся через минуту-две.\n`); return; }
+        await new Promise(r => setTimeout(r, 1000));
+    }
+    fail("Prometheus не ответил за 30 с: journalctl -u prometheus");
+}
+
+async function status() {
+    const ok = await ready();
+    console.log(`  пакет:     ${installed() ? "установлен" : "нет"}`);
+    console.log(`  сервис:    ${active() ? "работает" : "остановлен"}`);
+    console.log(`  наш конфиг: ${managed() ? "да" : "нет"}`);
+    console.log(`  готов:     ${ok ? `да, ${LISTEN}` : "нет"}`);
+}
+
+function remove() {
+    if (process.getuid?.() !== 0) fail("Нужен root: sudo awg-ctrl monitor remove");
+    // Чужой Prometheus не удаляем: у него могут быть свои данные и задачи, которых мы не ставили.
+    if (installed() && existsSync(CONF_FILE) && !managed()) {
+        fail(`Prometheus настроен не нами (${CONF_FILE}), поэтому панель его не удаляет. Если он не нужен: sudo apt purge prometheus`);
+    }
+
+    log("1/3  остановка сервиса");
+    sh("systemctl", ["disable", "--now", "prometheus"], { quiet: true });
+
+    log("2/3  токен");
+    for (const f of [TOKEN_FILE, MONITOR_HASH_FILE]) { try { unlinkSync(f); } catch { /* уже нет */ } }
+
+    log("3/3  удаление пакета и накопленных данных");
+    if (installed() && sh("apt-get", ["purge", "-y", "prometheus"]).status !== 0) fail("apt-get purge prometheus завершился ошибкой");
+
+    console.log("\n  ✓ Prometheus удалён вместе с накопленными графиками. Панель продолжает отдавать /metrics.\n");
+}
+
+export async function monitorCmd(sub?: string) {
+    switch (sub) {
+        case "install": await install(); break;
+        case "status":  await status();  break;
+        case "remove":  remove();       break;
+        default: console.log("Usage: awg-ctrl monitor <install|status|remove>"); process.exit(1);
+    }
+}

cmd/awg-control/main.go

@@ -0,0 +1,66 @@
+// awg-control — единый бинарник Forgetting: роли ctrl / ui / agent и команды оператора.
+package main
+
+import (
+	"context"
+	"fmt"
+	"os"
+	"os/signal"
+	"syscall"
+
+	"github.com/maeneko/forgetting/internal/agent"
+	"github.com/maeneko/forgetting/internal/cli"
+	"github.com/maeneko/forgetting/internal/ctrl"
+	"github.com/maeneko/forgetting/internal/ui"
+)
+
+// version — из сборки релиза (-ldflags "-X main.version=…").
+var version = "dev"
+
+func main() {
+	// Без аргументов или с командой оператора — CLI (меню, start/stop/…), как прежний awg-ctrl.
+	if len(os.Args) < 2 {
+		cli.Main(nil)
+		return
+	}
+	switch os.Args[1] {
+	case "version":
+		fmt.Println(version)
+	case "ctrl":
+		s, err := ctrl.New()
+		if err != nil {
+			fmt.Fprintln(os.Stderr, err)
+			os.Exit(1)
+		}
+		if err := s.Run(); err != nil {
+			fmt.Fprintln(os.Stderr, err)
+			os.Exit(1)
+		}
+	case "ui":
+		a, err := ui.New()
+		if err != nil {
+			fmt.Fprintln(os.Stderr, err)
+			os.Exit(1)
+		}
+		if err := a.Run(); err != nil {
+			fmt.Fprintln(os.Stderr, err)
+			os.Exit(1)
+		}
+	case "agent":
+		c, err := agent.ConfigFromEnv()
+		if err != nil {
+			fmt.Fprintln(os.Stderr, err)
+			os.Exit(1)
+		}
+		a, err := agent.New(c)
+		if err != nil {
+			fmt.Fprintln(os.Stderr, err)
+			os.Exit(1)
+		}
+		ctx, stop := signal.NotifyContext(context.Background(), os.Interrupt, syscall.SIGTERM)
+		defer stop()
+		a.Run(ctx)
+	default:
+		cli.Main(os.Args[1:])
+	}
+}

go.mod

@@ -0,0 +1,17 @@
+module github.com/maeneko/forgetting
+
+go 1.26.0
+
+require (
+	github.com/coder/websocket v1.8.15 // indirect
+	github.com/dustin/go-humanize v1.0.1 // indirect
+	github.com/google/uuid v1.6.0 // indirect
+	github.com/mattn/go-isatty v0.0.24 // indirect
+	github.com/ncruces/go-strftime v1.0.0 // indirect
+	github.com/remyoudompheng/bigfft v0.0.0-20230129092748-24d4a6f8daec // indirect
+	golang.org/x/sys v0.48.0 // indirect
+	modernc.org/libc v1.77.1 // indirect
+	modernc.org/mathutil v1.7.1 // indirect
+	modernc.org/memory v1.12.1 // indirect
+	modernc.org/sqlite v1.60.1 // indirect
+)

go.sum

@@ -0,0 +1,22 @@
+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/dustin/go-humanize v1.0.1 h1:GzkhY7T5VNhEkwH0PVJgjz+fX1rhBrR7pRT3mDkpeCY=
+github.com/dustin/go-humanize v1.0.1/go.mod h1:Mu1zIs6XwVuF/gI1OepvI0qD18qycQx+mFykh5fBlto=
+github.com/google/uuid v1.6.0 h1:NIvaJDMOsjHA8n1jAhLSgzrAzy1Hgr+hNrb57e+94F0=
+github.com/google/uuid v1.6.0/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo=
+github.com/mattn/go-isatty v0.0.24 h1:tGZZoVgT/KiqK1c8ocVLeDS8BSWMRd47J3Lbz7vsReI=
+github.com/mattn/go-isatty v0.0.24/go.mod h1:nMCL3Zebbrt45jsMDgnfIwz6ydEQApk5oEI3HqDio6A=
+github.com/ncruces/go-strftime v1.0.0 h1:HMFp8mLCTPp341M/ZnA4qaf7ZlsbTc+miZjCLOFAw7w=
+github.com/ncruces/go-strftime v1.0.0/go.mod h1:Fwc5htZGVVkseilnfgOVb9mKy6w1naJmn9CehxcKcls=
+github.com/remyoudompheng/bigfft v0.0.0-20230129092748-24d4a6f8daec h1:W09IVJc94icq4NjY3clb7Lk8O1qJ8BdBEF8z0ibU0rE=
+github.com/remyoudompheng/bigfft v0.0.0-20230129092748-24d4a6f8daec/go.mod h1:qqbHyh8v60DhA7CoWK5oRCqLrMHRGoxYCSS9EjAz6Eo=
+golang.org/x/sys v0.48.0 h1:bbX/i/6MgT9BVLM9RT1thmxL04yeTAhbEz4SyadbXoo=
+golang.org/x/sys v0.48.0/go.mod h1:hNLxWAXmnKAxqDtdwIYC4bM9oQPEecfsnNMuSxOs3og=
+modernc.org/libc v1.77.1 h1:Ct8j47QtiZ1Enj2DtFXQtUqrPCAjdCmPjtCuvrYQ0Hs=
+modernc.org/libc v1.77.1/go.mod h1:87/pZ4L6nD1zqW4nItuS12YO7hN1igAah34xjnQo/W0=
+modernc.org/mathutil v1.7.1 h1:GCZVGXdaN8gTqB1Mf/usp1Y/hSqgI2vAGGP4jZMCxOU=
+modernc.org/mathutil v1.7.1/go.mod h1:4p5IwJITfppl0G4sUEDtCr4DthTaT47/N3aT6MhfgJg=
+modernc.org/memory v1.12.1 h1:nFMiWrpStgZczNl6XI9GnIk/rWhYIyHGUaR04pGbp9g=
+modernc.org/memory v1.12.1/go.mod h1:/JP4VbVC+K5sU2wZi9bHoq2MAkCnrt2r98UGeSK7Mjw=
+modernc.org/sqlite v1.60.1 h1:/blz53O951KWFOso4QQvEs/Fq6cDBKLtMVrYNSeJVKw=
+modernc.org/sqlite v1.60.1/go.mod h1:1dIoEagfDE72QytD5scH1lxARtaUgKgHC/NuApA27r0=

install.sh

@@ -21,7 +21,7 @@ fail() { trap - ERR; echo -e "\n  ${RED}✗${NC}  $*" >&2; exit 1; }
 info() { echo -e "  ${DIM}→  $*${NC}"; }
 skip() { echo -e "  ${DIM}–  $*${NC}"; }
 rule() { echo -e "  ${DIM}────────────────────────────────────────────────────────${NC}"; }
-# Заголовок шага: step "1/7  AmneziaWG" → «▍ AmneziaWG   1 из 7»; без номера — просто заголовок.
+# Заголовок шага: step "1/6  AmneziaWG" → «▍ AmneziaWG   1 из 6»; без номера — просто заголовок.
 step() {
     if [[ "$1" =~ ^([0-9]+)/([0-9]+)\ +(.*)$ ]]; then
         echo -e "\n${ACC}▍${NC}${BLD} ${BASH_REMATCH[3]}${NC}  ${DIM}${BASH_REMATCH[1]} из ${BASH_REMATCH[2]}${NC}"
@@ -84,7 +84,7 @@ trap 'rc=$?; echo -e "\n  ${RED}✗ НЕОЖИДАННАЯ ОШИБКА${NC}  с
 [[ -z "${BASH_VERSION:-}" ]] && fail "Нужен bash: bash install.sh"
 
 # Лог установки — с первой строки: всё, что видно на экране (шапка, проверки, вопросы с
-# ответами, вывод apt/DKMS/npm), плюс то, что установщик раньше глушил. В файле — без цветов
+# ответами, вывод apt/DKMS), плюс то, что установщик раньше глушил. В файле — без цветов
 # и без перерисовок строк (ESC-последовательности и всё до последнего \r вырезаются).
 # Права 600: в итоге печатается пароль панели. LOGFILE — глобал, на него ссылается ERR-трап.
 LOGFILE="/var/log/awg-install-$(date +%Y%m%d-%H%M%S).log"
@@ -100,23 +100,29 @@ trap 'exec >&- 2>&-; wait "$LOG_PID" 2>/dev/null || true' EXIT
 # ⚠️ Дублирует .env из репозитория: установщик собирает URL релиза и печатает
 # баннер ДО того, как архив с .env скачан, поэтому взять их оттуда не может.
 # При бампе версии правь оба места.
-VERSION="0.3.4"
+VERSION="0.4.3"
 CHANNEL="${CHANNEL:-Beta}"
 
-# Откуда брать архив и как называется продукт — задаётся окружением, в коде
-# ничего не зашито. У Gitea и GitHub путь релиза одинаковый
-# (<repo>/releases/download/v<VERSION>/<file>), поэтому одна схема покрывает оба.
-#   REPO_BASE     — основной источник (своё зеркало);
-#   REPO_FALLBACK — запасной, если в основном релиза ещё нет;
+# Откуда брать архив и как называется продукт. По умолчанию — релизы на GitHub; источник
+# переопределяется окружением. Путь релиза — <repo>/releases/download/v<VERSION>/<file>
+# (такой же у Gitea, так что подойдёт и своё зеркало).
+#   REPO_BASE     — основной источник;
+#   REPO_FALLBACK — запасной, если в основном релиза нет (по умолчанию не задан);
 #   ARCHIVE_URL   — полный URL архива, перекрывает оба варианта;
 #   BRAND         — имя продукта в баннерах, systemd-юните и панели; по
 #                   умолчанию берётся из .env в архиве, здесь только запасное
 #                   значение для баннера самого установщика.
 BRAND_OVERRIDE="${BRAND:-}"
 BRAND="${BRAND:-Forgetting}"
-REPO_BASE="${REPO_BASE:-https://git.ma7neko.ru/maeneko/forgetting}"
-REPO_FALLBACK="${REPO_FALLBACK:-https://github.com/maeneko/forgetting}"
-ARCHIVE_NAME="awgcontrol-${VERSION}.tar.gz"
+REPO_BASE="${REPO_BASE:-https://github.com/maeneko/forgetting}"
+REPO_FALLBACK="${REPO_FALLBACK:-$REPO_BASE}"
+# Архив — под архитектуру: в нём готовый бинарник awg-control (Go, статический).
+case "$(uname -m)" in
+    x86_64|amd64)  GOARCH="amd64" ;;
+    aarch64|arm64) GOARCH="arm64" ;;
+    *)             GOARCH="" ;;
+esac
+ARCHIVE_NAME="awgcontrol-${VERSION}-linux-${GOARCH:-unknown}.tar.gz"
 ARCHIVE_URL="${ARCHIVE_URL:-}"
 url_host() { sed -E 's#^https?://([^/]+).*#\1#' <<< "$1"; }
 PROJECT="/opt/awg-control"
@@ -147,10 +153,9 @@ AWG_PORT="47619"
 SUBNET="10.9"
 MTU="1376"
 
-# Запуск CLI: tsx напрямую из node_modules (не npx) — чтобы PID был реальным
-# (та же причина, что у обёртки /usr/local/bin/awg-ctrl). Нужно обоим режимам.
-TSX="$PROJECT/cli/node_modules/.bin/tsx"
-CLI="$PROJECT/cli/src/index.ts"
+# Единый бинарник: сервисы (ctrl/ui/agent) и CLI (start/stop/status/…). Команда awg-ctrl —
+# ссылка на него.
+BIN="$PROJECT/awg-control"
 
 echo
 echo -e "  ${ACC}◆${NC} ${BLD}${BRAND}${NC}  ${DIM}${CHANNEL} · ${VERSION}${NC}"
@@ -270,8 +275,14 @@ echo -e "  ${DIM}${OS_NAME:-$(lsb_release -ds 2>/dev/null || echo unknown)} ·
 # Считаем все пункты, НЕ падая на первом, — чтобы показать полный чеклист
 # со статусом по каждому. Если хоть один не прошёл — печатаем причины и выходим
 # с кодом 0 (чистый выход, без вида «упало с ошибкой»).
-OS_OK=1; VIRT_OK=1; HDR_OK=1; NET_OK=1
-OS_WHY=""; VIRT_WHY=""; HDR_WHY=""; NET_WHY=""
+OS_OK=1; ARCH_OK=1; VIRT_OK=1; HDR_OK=1; NET_OK=1
+OS_WHY=""; ARCH_WHY=""; VIRT_WHY=""; HDR_WHY=""; NET_WHY=""
+
+# Архитектура: релиз собирается под amd64 и arm64.
+if [[ -z "$GOARCH" ]]; then
+    ARCH_OK=0
+    ARCH_WHY="архитектура '$(uname -m)' не поддерживается — сборки есть для x86_64 и aarch64"
+fi
 
 # 0) Дистрибутив: установщик умеет только apt-семейство Ubuntu/Debian.
 if [[ -z "$OS_FAMILY" ]]; then
@@ -304,7 +315,7 @@ if [[ "$ROLE" != "core" ]]; then
     fi
 fi
 
-# 3) Доступ в интернет: нужен для архива, Node и пакетов AWG. Без -f: любой
+# 3) Доступ в интернет: нужен для архива и пакетов AWG. Без -f: любой
 #    HTTP-ответ = связь есть; ненулевой код только при сбое соединения/DNS.
 #    Проверяем хосты, с которых реально качаем: хватает любого из двух —
 #    download_extract() умеет откатываться на запасной.
@@ -321,16 +332,18 @@ done
 # Чеклист: ✓ — пройдено, ✗ — нет.
 mark() { if [[ "$1" == 1 ]]; then echo -e "  ${GRN}✓${NC}  $2"; else echo -e "  ${RED}✗${NC}  $2"; fi; }
 mark "$OS_OK"   "Дистрибутив"
+mark "$ARCH_OK" "Архитектура"
 if [[ "$ROLE" != "core" ]]; then
     mark "$VIRT_OK" "Виртуализация"
     mark "$HDR_OK"  "Заголовки ядра"
 fi
 mark "$NET_OK"  "Доступ в интернет"
 
-if [[ "$OS_OK" == 0 || "$VIRT_OK" == 0 || "$HDR_OK" == 0 || "$NET_OK" == 0 ]]; then
+if [[ "$OS_OK" == 0 || "$ARCH_OK" == 0 || "$VIRT_OK" == 0 || "$HDR_OK" == 0 || "$NET_OK" == 0 ]]; then
     echo
     warn "Установка невозможна — не пройдены проверки:"
     [[ "$OS_OK"   == 0 ]] && echo -e "    ${RED}•${NC} $OS_WHY"
+    [[ "$ARCH_OK" == 0 ]] && echo -e "    ${RED}•${NC} $ARCH_WHY"
     [[ "$VIRT_OK" == 0 ]] && echo -e "    ${RED}•${NC} $VIRT_WHY"
     [[ "$HDR_OK"  == 0 ]] && echo -e "    ${RED}•${NC} $HDR_WHY"
     [[ "$NET_OK"  == 0 ]] && echo -e "    ${RED}•${NC} $NET_WHY"
@@ -388,14 +401,19 @@ NET_IFACE=$(ip route show default 2>/dev/null | awk '/default/{print $5; exit}')
 
 # Сначала корректно через CLI (по PID-файлам), затем добиваем всё, что ещё
 # держит файлы проекта: осиротевшие процессы, ручной запуск или stale PID,
-# которые `stop all` не находит. Вызывать ДО `rm -rf $PROJECT` — иначе node
-# продолжит работать с уже удалёнными файлами и порт/интерфейс останутся занятыми.
+# которые `stop all` не находит. Вызывать ДО `rm -rf $PROJECT` — иначе сервисы
+# продолжат работать с уже удалёнными файлами и порт/интерфейс останутся занятыми.
 kill_related() {
-    local _tsx="$PROJECT/cli/node_modules/.bin/tsx"
-    local _cli="$PROJECT/cli/src/index.ts"
-    [[ -x "$_tsx" && -f "$_cli" ]] && "$_tsx" "$_cli" stop all 2>/dev/null || true
+    if [[ -x "$BIN" ]]; then
+        "$BIN" stop all 2>/dev/null || true
+    else
+        # Установка до Go-версии: её CLI на tsx.
+        local _tsx="$PROJECT/cli/node_modules/.bin/tsx"
+        local _cli="$PROJECT/cli/src/index.ts"
+        [[ -x "$_tsx" && -f "$_cli" ]] && "$_tsx" "$_cli" stop all 2>/dev/null || true
+    fi
 
-    # cmdline всех сервисов (tsx awg-ctrl/awg-ui/cli) содержит путь проекта.
+    # cmdline всех сервисов (awg-control <роль>, у старых — tsx …) содержит путь проекта.
     if command -v pkill &>/dev/null; then
         pkill -TERM -f "$PROJECT/" 2>/dev/null || true
         sleep 1
@@ -420,7 +438,7 @@ download_extract() {
 
     # AWG_LOCAL_TARBALL — поставить сборку, которой ещё нет в релизах (или
     # встать без сети). Архив должен быть той же формы, что делает CI:
-    # awg-ctrl/ + awg-ui/ (с готовым dist/) + cli/ + .env, без node_modules.
+    # awg-control (бинарник под эту архитектуру) + awg-ui/dist/ + .env.
     if [[ -n "${AWG_LOCAL_TARBALL:-}" ]]; then
         [[ -f "$AWG_LOCAL_TARBALL" ]] \
             || fail "AWG_LOCAL_TARBALL указан, но файл не найден: $AWG_LOCAL_TARBALL"
@@ -451,42 +469,40 @@ $(printf '    %s\n' "${urls[@]}")
     fi
 
     mkdir -p "$PROJECT"
+    remove_legacy
     run tar -xzf "$tmp" -C "$PROJECT" --strip-components=1 \
         || fail "Не удалось распаковать архив"
     [[ "$keep_tarball" == 1 ]] || rm -f "$tmp"
     ok "Распакован → $PROJECT"
 
     local f
-    for f in \
-        "$PROJECT/awg-ctrl/index.ts" \
-        "$PROJECT/awg-ctrl/package.json" \
-        "$PROJECT/awg-ui/public/index.html" \
-        "$PROJECT/awg-ui/server.ts" \
-        "$PROJECT/awg-ui/package.json" \
-        "$PROJECT/awg-agent/index.ts" \
-        "$PROJECT/awg-agent/package.json" \
-        "$PROJECT/cli/src/index.ts" \
-        "$PROJECT/cli/package.json"
-    do
+    for f in "$BIN" "$PROJECT/awg-ui/dist/index.html" "$PROJECT/.env"; do
         [[ -f "$f" ]] || fail "Файл не найден после распаковки: $f"
     done
+    # Рабочие каталоги сервисов: в них живут panel.id, логи awg-ctrl, cli.env.
+    mkdir -p "$PROJECT/awg-ctrl" "$PROJECT/awg-ui" "$PROJECT/awg-agent" "$PROJECT/cli" "$PROJECT/logs"
+    chmod 755 "$BIN"
+    "$BIN" version >/dev/null 2>&1 || fail "Бинарник $BIN не запускается (архив не под эту архитектуру?)"
     ok "Архив проверен"
 }
 
-# npm install во всех сервисах.
-npm_install_all() {
-    local SVC
-    for SVC in awg-ctrl awg-ui awg-agent cli; do
-        if [[ -f "$PROJECT/$SVC/package.json" ]]; then
-            info "npm install · $SVC"
-            (cd "$PROJECT/$SVC" && run npm install) \
-                || fail "npm install в $SVC завершился ошибкой"
-        else
-            warn "$PROJECT/$SVC/package.json не найден — пропуск"
-        fi
+# remove_legacy — при обновлении убрать код прежней версии: TS-исходники, node_modules и старую
+# сборку фронтенда. Данные остаются: cli/cli.env, awg-ui/panel.id, логи (базы и ключи — в /etc).
+remove_legacy() {
+    local d
+    for d in awg-ctrl awg-ui awg-agent cli; do
+        [[ -d "$PROJECT/$d" ]] || continue
+        rm -rf "$PROJECT/$d/node_modules" "$PROJECT/$d/src" "$PROJECT/$d/public" "$PROJECT/$d/dist"
+        rm -f "$PROJECT/$d"/*.ts "$PROJECT/$d"/package*.json "$PROJECT/$d"/tsconfig*.json "$PROJECT/$d/index.html"
     done
 }
 
+# Команда awg-ctrl — ссылка на бинарник: CLI находит корень установки по её цели.
+install_command() {
+    ln -sfn "$BIN" /usr/local/bin/awg-ctrl
+    ok "awg-ctrl → $BIN"
+}
+
 # systemd-юнит: автозапуск awg-control на загрузке. Модель CLI — детач-процессы
 # с PID-файлами (а не один долгоживущий процесс), поэтому Type=oneshot +
 # RemainAfterExit: systemd держит юнит «active», процессами рулит CLI через
@@ -494,12 +510,8 @@ npm_install_all() {
 # вручную не выполняется — поднимаем интерфейс в ExecStartPre (если ещё не поднят).
 SERVICE_UNIT="/etc/systemd/system/awg-control.service"
 setup_service() {
-    # node может стоять вне дефолтного PATH systemd (nvm и т.п.), а tsx
-    # запускается через shebang `#!/usr/bin/env node` — иначе ExecStart падает с
-    # кодом 127 «node not found». Прописываем реальный каталог node в PATH юнита;
-    # sbin тоже включаем (awg-quick зовёт iptables/ip/sysctl).
-    local node_dir pre="" what
-    node_dir=$(dirname "$(command -v node 2>/dev/null || echo /usr/bin/node)")
+    # sbin в PATH юнита: awg-quick зовёт iptables/ip/sysctl.
+    local pre="" what
     # Панели без VPN (core) интерфейс не нужен — ExecStartPre только там, где есть awg-ctrl.
     [[ "$ROLE" != "core" ]] && pre="ExecStartPre=/bin/sh -c 'awg show ${IFACE} >/dev/null 2>&1 || awg-quick up ${IFACE}'"
     case "$ROLE" in
@@ -516,7 +528,7 @@ Wants=network-online.target
 [Service]
 Type=oneshot
 RemainAfterExit=yes
-Environment=PATH=${node_dir}:/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin
+Environment=PATH=/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin
 ${pre}
 ExecStart=/usr/local/bin/awg-ctrl start all
 ExecStop=/usr/local/bin/awg-ctrl stop all
@@ -539,10 +551,10 @@ start_and_status() {
             || fail "systemctl restart awg-control завершился ошибкой"
     else
         warn "systemd не найден — запускаю напрямую через CLI (без автозапуска)"
-        run "$TSX" "$CLI" start all
+        run "$BIN" start all
     fi
     sleep 2
-    "$TSX" "$CLI" status
+    "$BIN" status
 }
 
 if [[ "$INSTALL_MODE" == "update" ]]; then
@@ -552,7 +564,7 @@ if [[ "$INSTALL_MODE" == "update" ]]; then
     kill_related
 
     download_extract
-    npm_install_all
+    install_command
     start_and_status
 
     rule
@@ -792,7 +804,7 @@ ask YN "Продолжить? [Y/n]: "
 
 # Совместимость (виртуализация, заголовки ядра, интернет) проверена выше в
 # секции «Проверка совместимости»; $KERNEL задан там же.
-step "1/7  AmneziaWG"
+step "1/6  AmneziaWG"
 
 if [[ "$ROLE" == "core" ]]; then
     skip "пропущено — у панели без VPN AmneziaWG не нужен"
@@ -1022,24 +1034,11 @@ else
     fi
 fi
 
-step "2/7  Node.js"
-
-if command -v node &>/dev/null; then
-    ok "Node.js уже установлен: $(node --version)"
-else
-    info "установка Node.js 20.x (nodesource)"
-    run bash -c 'set -o pipefail; curl -fsSL https://deb.nodesource.com/setup_20.x | bash -' \
-        || fail "Не удалось подключить репозиторий Node.js (deb.nodesource.com)"
-    DEBIAN_FRONTEND=noninteractive NEEDRESTART_MODE=a \
-        run apt-get install -y nodejs || fail "Не удалось установить Node.js"
-    ok "Node.js установлен: $(node --version)"
-fi
-
-step "3/7  Файлы проекта"
+step "2/6  Файлы проекта"
 
 download_extract
 
-step "4/7  Ключи и конфиг AWG"
+step "3/6  Ключи и конфиг AWG"
 
 mkdir -p "$AWG_DIR" "$AMNEZIA_DIR"
 
@@ -1196,7 +1195,7 @@ CONF
     fi
 fi
 
-step "5/7  Запуск AWG"
+step "4/6  Запуск AWG"
 
 if [[ "$ROLE" == "core" ]]; then
     skip "пропущено — у панели без VPN интерфейса нет"
@@ -1307,21 +1306,11 @@ else
     info "UFW не активен, правила фаервола не трогаем"
 fi
 
-step "6/7  npm install"
+step "5/6  Команда awg-ctrl"
 
-npm_install_all
+install_command
 
-# Глобальный бинарник — используем tsx напрямую из node_modules (не npx)
-# чтобы child.pid в cli был реальным PID процесса
-cat > /usr/local/bin/awg-ctrl << 'WRAPPER'
-#!/usr/bin/env bash
-exec /opt/awg-control/cli/node_modules/.bin/tsx \
-     /opt/awg-control/cli/src/index.ts "$@"
-WRAPPER
-chmod +x /usr/local/bin/awg-ctrl
-ok "awg-ctrl → /usr/local/bin/awg-ctrl"
-
-step "7/7  Запуск сервисов"
+step "6/6  Запуск сервисов"
 
 # cli.env по роли. Роль CLI узнаёт отсюда же: CORE_HOST → нода (awg-ctrl + awg-agent),
 # LOCAL_NODE=off → панель без VPN (только awg-ui), иначе — awg-ctrl + awg-ui.

internal/agent/agent.go

@@ -0,0 +1,447 @@
+// Package agent — агент ноды (порт awg-agent/index.ts). Сам открывает исходящее
+// WSS-соединение к core (awg-ui), доказывает свою личность подписью Ed25519 и исполняет
+// присланные запросы на локальном awg-ctrl (127.0.0.1). Входящих портов у ноды нет,
+// awg-ctrl остаётся закрытым от сети. Протокол и формат join-строки — docs/node-protocol.md.
+package agent
+
+import (
+	"bytes"
+	"context"
+	"crypto/ed25519"
+	"crypto/rand"
+	"crypto/sha256"
+	"crypto/tls"
+	"crypto/x509"
+	"encoding/base64"
+	"encoding/pem"
+	"errors"
+	"fmt"
+	"io"
+	"net/http"
+	"net/url"
+	"os"
+	"path/filepath"
+	"regexp"
+	"strconv"
+	"strings"
+	"sync"
+	"time"
+
+	"github.com/coder/websocket"
+
+	"github.com/maeneko/forgetting/internal/iauth"
+	"github.com/maeneko/forgetting/internal/jsjson"
+)
+
+var b64 = base64.RawURLEncoding
+
+const (
+	handshakeTimeout = 10 * time.Second
+	deadAfter        = 60 * time.Second // core пингует чаще; тишина дольше — соединение мёртвое
+	maxPayload       = 4 * 1024 * 1024
+	ctrlTimeout      = 110 * time.Second
+	maxBackoff       = 60 * time.Second
+	closeAuthFailed  = 4003
+)
+
+type Config struct {
+	CoreHost     string
+	CorePort     int
+	CorePin      string // SHA-256 SPKI сертификата core, base64url
+	NodeID       int
+	Ctrl         string // http://127.0.0.1:PORT
+	NodeKeyFile  string
+	InternalKey  string
+	CLIEnvFile   string
+	JoinSecret   string // одноразовый, живёт до первого успешного подключения
+	Version      string
+	Logf, Errorf func(format string, a ...any)
+}
+
+// envFromFile — значение KEY=… из .env (как в Node-версии: первая строка, обрезанная).
+func envFromFile(file, key string) string {
+	raw, err := os.ReadFile(file)
+	if err != nil {
+		return ""
+	}
+	m := regexp.MustCompile(`(?m)^\s*` + regexp.QuoteMeta(key) + `\s*=\s*(.*)$`).FindSubmatch(raw)
+	if m == nil {
+		return ""
+	}
+	return strings.TrimSpace(string(m[1]))
+}
+
+// ConfigFromEnv собирает конфиг так же, как Node-агент. Каталог агента — рабочий каталог
+// процесса (CLI запускает сервис с cwd = <root>/awg-agent): там node.key по умолчанию, а
+// .env проекта — уровнем выше.
+func ConfigFromEnv() (Config, error) {
+	cwd, _ := os.Getwd()
+	atoi := func(k string) int { n, _ := strconv.Atoi(strings.TrimSpace(os.Getenv(k))); return n }
+	or := func(k, def string) string {
+		if v, ok := os.LookupEnv(k); ok {
+			return v
+		}
+		return def
+	}
+	c := Config{
+		CoreHost:    os.Getenv("CORE_HOST"),
+		CorePort:    atoi("CORE_PORT"),
+		CorePin:     os.Getenv("CORE_PIN"),
+		NodeID:      atoi("NODE_ID"),
+		Ctrl:        "http://127.0.0.1:" + or("AWGCTRL_PORT", "3005"),
+		NodeKeyFile: or("NODE_KEY_FILE", filepath.Join(cwd, "node.key")),
+		InternalKey: or("INTERNAL_AUTH_KEY_FILE", "/etc/amnezia/amneziawg/internal_auth_private.key"),
+		CLIEnvFile:  os.Getenv("CLI_ENV_FILE"),
+		JoinSecret:  os.Getenv("JOIN_SECRET"),
+		Version:     os.Getenv("VERSION"),
+	}
+	if c.Version == "" {
+		c.Version = envFromFile(filepath.Join(cwd, "..", ".env"), "VERSION")
+	}
+	if c.CoreHost == "" || c.CorePort == 0 || c.CorePin == "" || c.NodeID == 0 {
+		return c, errors.New("agent: не заданы CORE_HOST / CORE_PORT / CORE_PIN / NODE_ID — выполните `awg-ctrl join <ссылка>`")
+	}
+	return c, nil
+}
+
+type Agent struct {
+	c           Config
+	nodeKey     ed25519.PrivateKey
+	nodePubRaw  string
+	internalKey ed25519.PrivateKey // nil — запросы к awg-ctrl уйдут без токена и получат 401
+
+	mu         sync.Mutex
+	joinSecret string
+
+	http *http.Client
+}
+
+// loadNodeKey — личность ноды (Ed25519): создаётся один раз, приватная часть с ноды не уходит.
+func loadNodeKey(file string, logf func(string, ...any)) (ed25519.PrivateKey, error) {
+	if _, err := os.Stat(file); errors.Is(err, os.ErrNotExist) {
+		_, priv, err := ed25519.GenerateKey(rand.Reader)
+		if err != nil {
+			return nil, err
+		}
+		der, err := x509.MarshalPKCS8PrivateKey(priv)
+		if err != nil {
+			return nil, err
+		}
+		if err := os.WriteFile(file, pem.EncodeToMemory(&pem.Block{Type: "PRIVATE KEY", Bytes: der}), 0o600); err != nil {
+			return nil, err
+		}
+		logf("agent: создан ключ ноды %s", file)
+	}
+	return iauth.LoadPrivate(file)
+}
+
+func New(c Config) (*Agent, error) {
+	if c.Logf == nil {
+		c.Logf = func(f string, a ...any) { fmt.Fprintf(os.Stdout, f+"\n", a...) }
+	}
+	if c.Errorf == nil {
+		c.Errorf = func(f string, a ...any) { fmt.Fprintf(os.Stderr, f+"\n", a...) }
+	}
+	key, err := loadNodeKey(c.NodeKeyFile, c.Logf)
+	if err != nil {
+		return nil, fmt.Errorf("agent: ключ ноды %s: %w", c.NodeKeyFile, err)
+	}
+	a := &Agent{
+		c: c, nodeKey: key, joinSecret: c.JoinSecret,
+		nodePubRaw: b64.EncodeToString(key.Public().(ed25519.PublicKey)),
+		// awg-ctrl на loopback: системный прокси (HTTPS_PROXY и т. п.) сюда не нужен.
+		http: &http.Client{Transport: &http.Transport{Proxy: nil}, Timeout: ctrlTimeout},
+	}
+	if ik, err := iauth.LoadPrivate(c.InternalKey); err == nil {
+		a.internalKey = ik
+	} else {
+		c.Errorf("agent: приватный ключ внутренней авторизации не найден: %s", c.InternalKey)
+	}
+	return a, nil
+}
+
+// authMsg дублируется в awg-ui/nodes.ts.
+func authMsg(nonce string, nodeID int) []byte {
+	return []byte("awg-node-v1\n" + nonce + "\n" + strconv.Itoa(nodeID))
+}
+
+// ── Запросы core → awg-ctrl ────────────────────────────────────────────────
+
+var methods = map[string]bool{"GET": true, "POST": true, "PUT": true, "DELETE": true}
+
+var rePath = regexp.MustCompile(`^/[\x21-\x7e]*$`)
+
+// pathAllowed — агент не открытый прокси: только API самого awg-ctrl. Строже Node-версии
+// там, где та полагалась на нормализацию WHATWG URL: обратный слэш и «//» в начале
+// (смена хоста) отвергаются сразу, «.»/«..» — и в %2e-записи.
+func pathAllowed(p any) (string, bool) {
+	s, ok := p.(string)
+	if !ok || len(s) > 2048 || !rePath.MatchString(s) || strings.HasPrefix(s, "//") || strings.Contains(s, `\`) {
+		return "", false
+	}
+	pathname := s
+	if i := strings.IndexAny(pathname, "?#"); i >= 0 {
+		pathname = pathname[:i]
+	}
+	for _, seg := range strings.Split(pathname, "/") {
+		switch strings.ToLower(strings.ReplaceAll(strings.ReplaceAll(seg, "%2e", "."), "%2E", ".")) {
+		case ".", "..":
+			return "", false
+		}
+	}
+	if pathname == "/health" || strings.HasPrefix(pathname, "/api/") || strings.HasPrefix(pathname, "/awg/") {
+		return s, true
+	}
+	return "", false
+}
+
+type reply struct {
+	status int
+	data   any
+}
+
+func errReply(status int, msg string) reply {
+	return reply{status, jsjson.Object{{Key: "error", Val: msg}}}
+}
+
+// execute выполняет запрос core на локальном awg-ctrl. Ответ возвращается как его разобрал
+// бы axios: JSON — значением, иначе строкой (пустое тело — "").
+func (a *Agent) execute(m jsjson.Object) reply {
+	method, _ := m.Get2("method").(string)
+	method = strings.ToUpper(method)
+	p, ok := pathAllowed(m.Get2("path"))
+	if !methods[method] || !ok {
+		return errReply(400, "Запрос не разрешён агентом")
+	}
+	var body io.Reader
+	if v, has := m.Get("body"); has && v != nil {
+		raw, err := jsjson.Marshal(v)
+		if err != nil {
+			return errReply(400, "Запрос не разрешён агентом")
+		}
+		body = bytes.NewReader(raw)
+	}
+	u, err := url.Parse(a.c.Ctrl + p)
+	if err != nil {
+		return errReply(400, "Запрос не разрешён агентом")
+	}
+	u.Fragment = ""
+	req, err := http.NewRequest(method, u.String(), body)
+	if err != nil {
+		return errReply(400, "Запрос не разрешён агентом")
+	}
+	req.Header.Set("Content-Type", "application/json")
+	if a.internalKey != nil {
+		req.Header.Set("Authorization", "Bearer "+iauth.Mint(a.internalKey, "awg-agent", time.Now()))
+	}
+	resp, err := a.http.Do(req)
+	if err != nil {
+		return errReply(502, "awg-ctrl недоступен")
+	}
+	defer resp.Body.Close()
+	raw, err := io.ReadAll(resp.Body)
+	if err != nil {
+		return errReply(502, "awg-ctrl недоступен")
+	}
+	if len(raw) == 0 {
+		return reply{resp.StatusCode, ""}
+	}
+	if v, err := jsjson.Decode(raw); err == nil {
+		return reply{resp.StatusCode, v}
+	}
+	return reply{resp.StatusCode, string(raw)}
+}
+
+// ── Соединение с core ──────────────────────────────────────────────────────
+
+func spkiPin(rawCert []byte) (string, error) {
+	cert, err := x509.ParseCertificate(rawCert)
+	if err != nil {
+		return "", err
+	}
+	sum := sha256.Sum256(cert.RawSubjectPublicKeyInfo)
+	return b64.EncodeToString(sum[:]), nil
+}
+
+var errPin = errors.New("сертификат core не совпал с pin — соединение отклонено")
+
+// tlsConfig — сертификат core самоподписанный: цепочку не проверяем, доверие даёт pin.
+// Проверка внутри TLS-рукопожатия: секрет и подпись уходят только тому, чей сертификат
+// совпал с pin из join-строки.
+func (a *Agent) tlsConfig() *tls.Config {
+	return &tls.Config{
+		InsecureSkipVerify: true,
+		VerifyPeerCertificate: func(rawCerts [][]byte, _ [][]*x509.Certificate) error {
+			if len(rawCerts) == 0 {
+				return errPin
+			}
+			got, err := spkiPin(rawCerts[0])
+			if err != nil || got != a.c.CorePin {
+				return errPin
+			}
+			return nil
+		},
+	}
+}
+
+// forgetJoinSecret — после первого успешного входа секрет больше не нужен, убираем с диска.
+func (a *Agent) forgetJoinSecret() {
+	a.mu.Lock()
+	a.joinSecret = ""
+	a.mu.Unlock()
+	os.Unsetenv("JOIN_SECRET")
+	if a.c.CLIEnvFile == "" {
+		return
+	}
+	raw, err := os.ReadFile(a.c.CLIEnvFile)
+	if err != nil {
+		return // не критично: секрет одноразовый и с истекающим сроком
+	}
+	var kept []string
+	for _, l := range strings.Split(string(raw), "\n") {
+		if !strings.HasPrefix(l, "JOIN_SECRET=") {
+			kept = append(kept, l)
+		}
+	}
+	os.WriteFile(a.c.CLIEnvFile, []byte(strings.Join(kept, "\n")), 0o600)
+}
+
+func (a *Agent) secret() string {
+	a.mu.Lock()
+	defer a.mu.Unlock()
+	return a.joinSecret
+}
+
+// connectOnce держит одно соединение до его закрытия. authFailed — core закрыл с 4003.
+func (a *Agent) connectOnce(ctx context.Context, onReady func()) (authFailed bool) {
+	ctx, cancel := context.WithCancel(ctx)
+	defer cancel()
+
+	var dead *time.Timer
+	var deadMu sync.Mutex
+	armDead := func() {
+		deadMu.Lock()
+		defer deadMu.Unlock()
+		if dead != nil {
+			dead.Stop()
+		}
+		dead = time.AfterFunc(deadAfter, cancel)
+	}
+	defer func() {
+		deadMu.Lock()
+		if dead != nil {
+			dead.Stop()
+		}
+		deadMu.Unlock()
+	}()
+
+	tr := &http.Transport{Proxy: nil, TLSClientConfig: a.tlsConfig(), TLSHandshakeTimeout: handshakeTimeout}
+	dctx, dcancel := context.WithTimeout(ctx, handshakeTimeout)
+	ws, _, err := websocket.Dial(dctx, fmt.Sprintf("wss://%s/node/v1", hostPort(a.c.CoreHost, a.c.CorePort)), &websocket.DialOptions{
+		HTTPClient:      &http.Client{Transport: tr},
+		CompressionMode: websocket.CompressionDisabled,
+		OnPingReceived:  func(context.Context, []byte) bool { armDead(); return true },
+	})
+	dcancel()
+	if err != nil {
+		if errors.Is(err, errPin) {
+			a.c.Errorf("agent: %v", errPin)
+		} else {
+			a.c.Errorf("agent: %v", err)
+		}
+		return false
+	}
+	defer ws.CloseNow()
+	ws.SetReadLimit(maxPayload)
+
+	send := func(v any) {
+		if b, err := jsjson.Marshal(v); err == nil {
+			ws.Write(ctx, websocket.MessageText, b)
+		}
+	}
+
+	ready := false
+	for {
+		_, raw, err := ws.Read(ctx)
+		if err != nil {
+			code := websocket.CloseStatus(err)
+			if !ready && code == -1 && ctx.Err() == nil {
+				a.c.Errorf("agent: %v", err)
+			}
+			if code == closeAuthFailed {
+				a.c.Errorf("agent: core отклонил ноду (неверный ключ, просроченная или использованная ссылка)")
+			}
+			return code == closeAuthFailed
+		}
+		v, err := jsjson.Decode(raw)
+		if err != nil {
+			return false
+		}
+		m, _ := v.(jsjson.Object)
+		switch t, _ := m.Get2("t").(string); {
+		case t == "hello":
+			nonce, ok := m.Get2("nonce").(string)
+			if !ok {
+				continue
+			}
+			auth := jsjson.Object{
+				{Key: "t", Val: "auth"}, {Key: "node_id", Val: a.c.NodeID},
+				{Key: "sig", Val: b64.EncodeToString(ed25519.Sign(a.nodeKey, authMsg(nonce, a.c.NodeID)))},
+			}
+			if s := a.secret(); s != "" {
+				auth = append(auth, jsjson.KV{Key: "join", Val: jsjson.Object{{Key: "secret", Val: s}, {Key: "pub", Val: a.nodePubRaw}}})
+			}
+			if a.c.Version != "" {
+				auth = append(auth, jsjson.KV{Key: "version", Val: a.c.Version})
+			}
+			send(auth)
+		case t == "ready":
+			ready = true
+			armDead()
+			if onReady != nil {
+				onReady()
+			}
+			if a.secret() != "" {
+				a.forgetJoinSecret()
+				a.c.Logf("agent: нода привязана к core")
+			}
+			a.c.Logf("agent: подключено к core")
+		case t == "req" && ready:
+			id, ok := m.Get2("id").(float64)
+			if !ok || id != float64(int64(id)) {
+				continue
+			}
+			// Запросы независимы, как async-обработчики в Node: медленный /awg/… не держит очередь.
+			go func() {
+				r := a.execute(m)
+				send(jsjson.Object{{Key: "t", Val: "res"}, {Key: "id", Val: id}, {Key: "status", Val: r.status}, {Key: "data", Val: r.data}})
+			}()
+		}
+	}
+}
+
+func hostPort(host string, port int) string {
+	if strings.Contains(host, ":") && !strings.HasPrefix(host, "[") {
+		host = "[" + host + "]"
+	}
+	return host + ":" + strconv.Itoa(port)
+}
+
+// Run переподключается вечно: экспоненциальная пауза до минуты, после отказа core — минута.
+func (a *Agent) Run(ctx context.Context) error {
+	a.c.Logf("agent: нода #%d → wss://%s", a.c.NodeID, hostPort(a.c.CoreHost, a.c.CorePort))
+	backoff := time.Second
+	for {
+		authFailed := a.connectOnce(ctx, func() { backoff = time.Second })
+		wait := backoff
+		if authFailed {
+			wait = maxBackoff
+		}
+		backoff = min(backoff*2, maxBackoff)
+		select {
+		case <-ctx.Done():
+			return ctx.Err()
+		case <-time.After(wait):
+		}
+	}
+}

internal/agent/agent_test.go

@@ -0,0 +1,270 @@
+package agent
+
+import (
+	"context"
+	"crypto/ed25519"
+	"crypto/rand"
+	"crypto/x509"
+	"encoding/pem"
+	"io"
+	"net/http"
+	"net/http/httptest"
+	"net/url"
+	"os"
+	"path/filepath"
+	"strconv"
+	"strings"
+	"testing"
+	"time"
+
+	"github.com/coder/websocket"
+
+	"github.com/maeneko/forgetting/internal/iauth"
+	"github.com/maeneko/forgetting/internal/jsjson"
+)
+
+func TestPathAllowed(t *testing.T) {
+	for p, want := range map[any]bool{
+		"/health":                           true,
+		"/api/users":                        true,
+		"/api/users/a?x=1":                  true,
+		"/awg/upgrade":                      true,
+		"/healthz":                          false,
+		"/api":                              false,
+		"/etc/passwd":                       false,
+		"//evil.com/api/x":                  false,
+		`/\evil.com/api/x`:                  false,
+		"/api/../etc":                       false,
+		"/api/%2e%2E/etc":                   false,
+		"/api/./x":                          false,
+		"/api/a b":                          false,
+		"api/users":                         false,
+		42:                                  false,
+		"/api/" + strings.Repeat("a", 2048): false,
+	} {
+		if _, got := pathAllowed(p); got != want {
+			t.Errorf("pathAllowed(%v) = %v, want %v", p, got, want)
+		}
+	}
+}
+
+func writeKey(t *testing.T, file string, priv ed25519.PrivateKey) {
+	der, err := x509.MarshalPKCS8PrivateKey(priv)
+	if err != nil {
+		t.Fatal(err)
+	}
+	os.WriteFile(file, pem.EncodeToMemory(&pem.Block{Type: "PRIVATE KEY", Bytes: der}), 0o600)
+}
+
+type core struct {
+	srv    *httptest.Server
+	frames chan jsjson.Object // всё, что прислал агент
+	script func(ctx context.Context, ws *websocket.Conn, read func() jsjson.Object)
+}
+
+func newCore(t *testing.T, script func(ctx context.Context, ws *websocket.Conn, read func() jsjson.Object)) *core {
+	c := &core{frames: make(chan jsjson.Object, 16), script: script}
+	c.srv = httptest.NewTLSServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		if r.URL.Path != "/node/v1" {
+			http.NotFound(w, r)
+			return
+		}
+		ws, err := websocket.Accept(w, r, nil)
+		if err != nil {
+			return
+		}
+		defer ws.CloseNow()
+		ctx := r.Context()
+		read := func() jsjson.Object {
+			_, raw, err := ws.Read(ctx)
+			if err != nil {
+				return nil
+			}
+			v, _ := jsjson.Decode(raw)
+			o, _ := v.(jsjson.Object)
+			c.frames <- o
+			return o
+		}
+		c.script(ctx, ws, read)
+	}))
+	t.Cleanup(c.srv.Close)
+	return c
+}
+
+func (c *core) pin(t *testing.T) string {
+	p, err := spkiPin(c.srv.Certificate().Raw)
+	if err != nil {
+		t.Fatal(err)
+	}
+	return p
+}
+
+func (c *core) hostPort() (string, int) {
+	u, _ := url.Parse(c.srv.URL)
+	port, _ := strconv.Atoi(u.Port())
+	return u.Hostname(), port
+}
+
+func newAgent(t *testing.T, c *core, pin, ctrlURL string) (*Agent, string) {
+	dir := t.TempDir()
+	host, port := c.hostPort()
+	_, ik, _ := ed25519.GenerateKey(rand.Reader)
+	writeKey(t, filepath.Join(dir, "internal.key"), ik)
+	envFile := filepath.Join(dir, "cli.env")
+	os.WriteFile(envFile, []byte("CORE_HOST=x\nJOIN_SECRET=s3cret\nNODE_ID=7\n"), 0o600)
+	a, err := New(Config{
+		CoreHost: host, CorePort: port, CorePin: pin, NodeID: 7, Ctrl: ctrlURL,
+		NodeKeyFile: filepath.Join(dir, "node.key"), InternalKey: filepath.Join(dir, "internal.key"),
+		CLIEnvFile: envFile, JoinSecret: "s3cret", Version: "Beta 0.3.4",
+		Logf: t.Logf, Errorf: t.Logf,
+	})
+	if err != nil {
+		t.Fatal(err)
+	}
+	return a, envFile
+}
+
+func send(ctx context.Context, ws *websocket.Conn, v any) {
+	ws.Write(ctx, websocket.MessageText, jsjson.MustMarshal(v))
+}
+
+func TestHandshakeAndRequests(t *testing.T) {
+	var internalPub ed25519.PublicKey
+	ctrl := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		tok := strings.TrimPrefix(r.Header.Get("Authorization"), "Bearer ")
+		if !iauth.Verify(internalPub, tok, time.Now()) {
+			w.WriteHeader(401)
+			io.WriteString(w, `{"error":"Неверная авторизация"}`)
+			return
+		}
+		body, _ := io.ReadAll(r.Body)
+		switch r.URL.Path {
+		case "/api/users":
+			w.Header().Set("Content-Type", "application/json")
+			w.WriteHeader(201)
+			io.WriteString(w, `{"got":`+string(body)+`, "q":"`+r.URL.RawQuery+`"}`)
+		case "/health":
+			io.WriteString(w, "ok")
+		default:
+			w.WriteHeader(204)
+		}
+	}))
+	defer ctrl.Close()
+
+	results := make(chan jsjson.Object, 8)
+	c := newCore(t, func(ctx context.Context, ws *websocket.Conn, read func() jsjson.Object) {
+		send(ctx, ws, jsjson.Object{{Key: "t", Val: "hello"}, {Key: "nonce", Val: "n0nce"}})
+		auth := read()
+		if auth == nil {
+			return
+		}
+		join, _ := auth.Get2("join").(jsjson.Object)
+		pubRaw, _ := b64.DecodeString(join.Get2("pub").(string))
+		sig, _ := b64.DecodeString(auth.Get2("sig").(string))
+		if !ed25519.Verify(pubRaw, authMsg("n0nce", 7), sig) {
+			ws.Close(4003, "unauthorized")
+			return
+		}
+		send(ctx, ws, jsjson.Object{{Key: "t", Val: "ready"}})
+		send(ctx, ws, jsjson.Object{{Key: "t", Val: "req"}, {Key: "id", Val: 1}, {Key: "method", Val: "post"},
+			{Key: "path", Val: "/api/users?x=1"}, {Key: "body", Val: jsjson.Object{{Key: "name", Val: "alice"}}}})
+		send(ctx, ws, jsjson.Object{{Key: "t", Val: "req"}, {Key: "id", Val: 2}, {Key: "method", Val: "GET"}, {Key: "path", Val: "/etc/passwd"}})
+		send(ctx, ws, jsjson.Object{{Key: "t", Val: "req"}, {Key: "id", Val: 3}, {Key: "method", Val: "GET"}, {Key: "path", Val: "/health"}})
+		send(ctx, ws, jsjson.Object{{Key: "t", Val: "req"}, {Key: "id", Val: 4}, {Key: "method", Val: "DELETE"}, {Key: "path", Val: "/api/x"}})
+		for range 4 {
+			if r := read(); r != nil {
+				results <- r
+			}
+		}
+		ws.Close(websocket.StatusNormalClosure, "")
+	})
+
+	a, envFile := newAgent(t, c, c.pin(t), ctrl.URL)
+	internalPub = a.internalKey.Public().(ed25519.PublicKey)
+
+	ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
+	defer cancel()
+	if a.connectOnce(ctx, nil) {
+		t.Fatal("authFailed on a good handshake")
+	}
+
+	auth := <-c.frames
+	want := `{"t":"auth","node_id":7,"sig":"` + auth.Get2("sig").(string) + `","join":{"secret":"s3cret","pub":"` + a.nodePubRaw + `"},"version":"Beta 0.3.4"}`
+	if got := string(jsjson.MustMarshal(auth)); got != want {
+		t.Errorf("auth frame:\n got %s\nwant %s", got, want)
+	}
+
+	byID := map[float64]string{}
+	for range 4 {
+		r := <-results
+		byID[r.Get2("id").(float64)] = string(jsjson.MustMarshal(r))
+	}
+	for id, want := range map[float64]string{
+		1: `{"t":"res","id":1,"status":201,"data":{"got":{"name":"alice"},"q":"x=1"}}`,
+		2: `{"t":"res","id":2,"status":400,"data":{"error":"Запрос не разрешён агентом"}}`,
+		3: `{"t":"res","id":3,"status":200,"data":"ok"}`,
+		4: `{"t":"res","id":4,"status":204,"data":""}`,
+	} {
+		if byID[id] != want {
+			t.Errorf("res %v:\n got %s\nwant %s", id, byID[id], want)
+		}
+	}
+
+	// Секрет одноразовый: после ready он исчезает из памяти и из cli.env.
+	if a.secret() != "" {
+		t.Error("join secret still in memory")
+	}
+	if raw, _ := os.ReadFile(envFile); strings.Contains(string(raw), "JOIN_SECRET") || !strings.Contains(string(raw), "NODE_ID=7") {
+		t.Errorf("cli.env after join: %q", raw)
+	}
+}
+
+func TestWrongPinSendsNothing(t *testing.T) {
+	c := newCore(t, func(ctx context.Context, ws *websocket.Conn, read func() jsjson.Object) {
+		send(ctx, ws, jsjson.Object{{Key: "t", Val: "hello"}, {Key: "nonce", Val: "n"}})
+		read()
+	})
+	a, _ := newAgent(t, c, "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA", "http://127.0.0.1:1")
+	ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
+	defer cancel()
+	if a.connectOnce(ctx, nil) {
+		t.Fatal("pin mismatch reported as auth failure")
+	}
+	select {
+	case f := <-c.frames:
+		t.Fatalf("agent sent %v to a core with a foreign certificate", f)
+	default:
+	}
+}
+
+func TestAuthRejected(t *testing.T) {
+	c := newCore(t, func(ctx context.Context, ws *websocket.Conn, read func() jsjson.Object) {
+		send(ctx, ws, jsjson.Object{{Key: "t", Val: "hello"}, {Key: "nonce", Val: "n"}})
+		read()
+		ws.Close(4003, "unauthorized")
+	})
+	a, envFile := newAgent(t, c, c.pin(t), "http://127.0.0.1:1")
+	ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
+	defer cancel()
+	if !a.connectOnce(ctx, nil) {
+		t.Fatal("4003 not reported as auth failure")
+	}
+	if raw, _ := os.ReadFile(envFile); !strings.Contains(string(raw), "JOIN_SECRET=s3cret") {
+		t.Error("join secret dropped without a successful join")
+	}
+}
+
+func TestNodeKeyPersists(t *testing.T) {
+	file := filepath.Join(t.TempDir(), "node.key")
+	k1, err := loadNodeKey(file, t.Logf)
+	if err != nil {
+		t.Fatal(err)
+	}
+	k2, _ := loadNodeKey(file, t.Logf)
+	if !k1.Equal(k2) {
+		t.Fatal("node key regenerated")
+	}
+	if st, _ := os.Stat(file); st.Mode().Perm() != 0o600 {
+		t.Fatalf("node.key mode %v", st.Mode().Perm())
+	}
+}

internal/cli/cli.go

@@ -0,0 +1,619 @@
+// Package cli — менеджер процессов Forgetting (порт cli/src): start/stop/restart/status,
+// логин и пароль панели, join/unjoin ноды, пиры подписки, встроенный Prometheus и
+// интерактивное меню. Сервисы — тот же бинарник с ролью: `awg-control ctrl|ui|agent`.
+package cli
+
+import (
+	"bufio"
+	"errors"
+	"fmt"
+	"net/http"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"regexp"
+	"strconv"
+	"strings"
+	"syscall"
+	"time"
+
+	"github.com/maeneko/forgetting/internal/jsjson"
+)
+
+// ── Цвета ───────────────────────────────────────────────────────────────────
+
+const (
+	cReset = "\x1b[0m"
+	cBold  = "\x1b[1m"
+	cDim   = "\x1b[2m"
+	cGreen = "\x1b[32m"
+	cGrey  = "\x1b[90m"
+	cBlue  = "\x1b[34m"
+)
+
+func bold(s string) string  { return cBold + s + cReset }
+func green(s string) string { return cGreen + s + cReset }
+func grey(s string) string  { return cGrey + s + cReset }
+func dim(s string) string   { return cDim + s + cReset }
+
+func errorf(f string, a ...any) { fmt.Fprintf(os.Stderr, f+"\n", a...) }
+
+// ── Окружение ───────────────────────────────────────────────────────────────
+
+// findRoot — корень установки: AWG_ROOT, иначе ближайший предок каталога бинарника, где есть
+// cli/ или .env, иначе /opt/awg-control.
+func findRoot() string {
+	if r := os.Getenv("AWG_ROOT"); r != "" {
+		return r
+	}
+	if exe, err := os.Executable(); err == nil {
+		if real, err := filepath.EvalSymlinks(exe); err == nil {
+			exe = real
+		}
+		for d := filepath.Dir(exe); d != "/" && d != "."; d = filepath.Dir(d) {
+			if exists(filepath.Join(d, "cli")) || exists(filepath.Join(d, ".env")) {
+				return d
+			}
+		}
+	}
+	return "/opt/awg-control"
+}
+
+func exists(p string) bool {
+	_, err := os.Stat(p)
+	return err == nil
+}
+
+// loadEnvFile — уже заданное окружение не перетираем (??= в Node), поэтому порядок =
+// приоритет: реальное окружение → cli.env → .env в корне проекта.
+func loadEnvFile(file string) {
+	raw, err := os.ReadFile(file)
+	if err != nil {
+		return
+	}
+	for _, line := range strings.Split(string(raw), "\n") {
+		t := strings.TrimSpace(line)
+		if t == "" || strings.HasPrefix(t, "#") {
+			continue
+		}
+		i := strings.Index(t, "=")
+		if i < 0 {
+			continue
+		}
+		k := strings.TrimSpace(t[:i])
+		if _, set := os.LookupEnv(k); !set {
+			os.Setenv(k, strings.TrimSpace(t[i+1:]))
+		}
+	}
+}
+
+func env(k, def string) string {
+	if v, ok := os.LookupEnv(k); ok {
+		return v
+	}
+	return def
+}
+
+// envOr — `process.env.X || def`.
+func envOr(k, def string) string {
+	if v := os.Getenv(k); v != "" {
+		return v
+	}
+	return def
+}
+
+type service struct {
+	name    string // ctrl | ui | agent — роль бинарника
+	label   string
+	cwd     string
+	legacy  string // entry Node-версии: её процессы тоже узнаём (переход с TS)
+	env     [][2]string
+	pidFile string
+	logFile string
+}
+
+type CLI struct {
+	root    string
+	logs    string
+	envFile string
+	origEnv []string // окружение до чтения cli.env и .env — для свежего перезапуска
+	exe     string
+
+	brand, channel, version string
+
+	svc    map[string]*service
+	all    []string
+	isNode bool
+
+	in *bufio.Reader
+}
+
+func New() *CLI {
+	c := &CLI{root: findRoot(), origEnv: os.Environ(), in: bufio.NewReader(os.Stdin)}
+	c.exe, _ = os.Executable()
+	c.logs = filepath.Join(c.root, "logs")
+	os.MkdirAll(c.logs, 0o755)
+	c.envFile = filepath.Join(c.root, "cli", "cli.env")
+	loadEnvFile(c.envFile)                     // машинные настройки
+	loadEnvFile(filepath.Join(c.root, ".env")) // имя панели и версия
+
+	c.brand = envOr("BRAND", "Forgetting")
+	c.channel = envOr("CHANNEL", "Beta")
+	c.version = envOr("VERSION", "")
+
+	cliEnv := c.envFile
+	coreHost := os.Getenv("CORE_HOST")
+	audit := "off"
+	if coreHost == "" {
+		audit = env("AUDIT", "on")
+	}
+	c.svc = map[string]*service{
+		"awgctrl": {
+			name: "ctrl", label: "awg-ctrl", cwd: filepath.Join(c.root, "awg-ctrl"), legacy: "index.ts",
+			env: [][2]string{
+				{"PORT", env("AWGCTRL_PORT", "3005")},
+				{"SERVER_IP", env("SERVER_IP", "")},
+				{"SERVER_PORT", env("SERVER_PORT", "47619")},
+				{"SERVER_NAME", env("SERVER_NAME", "VPN")},
+				// Публичный ключ внутренней авторизации (awg-ctrl проверяет им токены awg-ui).
+				{"INTERNAL_AUTH_PUB_FILE", env("INTERNAL_AUTH_PUB_FILE", "/etc/amnezia/amneziawg/internal_auth_public.key")},
+			},
+			pidFile: "/tmp/awg-ctrl.pid", logFile: filepath.Join(c.logs, "awg-ctrl.log"),
+		},
+		"ui": {
+			name: "ui", label: "awg-ui", cwd: filepath.Join(c.root, "awg-ui"), legacy: "server.ts",
+			env: [][2]string{
+				{"PORT", env("UI_PORT", "8080")},
+				{"AWGCTRL_PORT", env("AWGCTRL_PORT", "3005")},
+				{"INTERNAL_AUTH_KEY_FILE", env("INTERNAL_AUTH_KEY_FILE", "/etc/amnezia/amneziawg/internal_auth_private.key")},
+				{"BRAND", c.brand}, {"CHANNEL", c.channel}, {"VERSION", c.version},
+				{"UI_USER", env("UI_USER", "admin")},
+				{"UI_PASS", env("UI_PASS", "")},
+				{"JWT_SECRET", env("JWT_SECRET", "")},
+				// ui.db в каталоге данных AWG (вне проекта) — переживает переустановку.
+				{"UI_DB_FILE", env("UI_DB_FILE", "/etc/amnezia/amneziawg/ui.db")},
+				// Подписка sen://: без SUB_PORT или ключа подписи awg-ui подписку не поднимает.
+				{"SUB_PORT", env("SUB_PORT", "")},
+				{"SUB_TLS", env("SUB_TLS", "off")},
+				{"SUB_SIGN_KEY_FILE", env("SUB_SIGN_KEY_FILE", "/etc/amnezia/amneziawg/sub_sign.key")},
+				{"SUB_TLS_KEY_FILE", env("SUB_TLS_KEY_FILE", "/etc/amnezia/amneziawg/sub_tls.key")},
+				{"SUB_TLS_CERT_FILE", env("SUB_TLS_CERT_FILE", "/etc/amnezia/amneziawg/sub_tls.crt")},
+				{"SUB_HOST", env("SUB_HOST", "")},
+				// Приём нод (core): без NODE_PORT хаб выключен. LOCAL_NODE=off — core без своего VPN.
+				{"NODE_PORT", env("NODE_PORT", "")},
+				// Часовой аудит пиров на всех серверах — только у core.
+				{"AUDIT", audit},
+				{"METRICS_PEERS", env("METRICS_PEERS", "off")},
+				{"LOCAL_NODE", env("LOCAL_NODE", "on")},
+				{"NODE_TLS_KEY_FILE", env("NODE_TLS_KEY_FILE", "/etc/amnezia/amneziawg/node_tls.key")},
+				{"NODE_TLS_CERT_FILE", env("NODE_TLS_CERT_FILE", "/etc/amnezia/amneziawg/node_tls.crt")},
+			},
+			pidFile: "/tmp/awg-ui.pid", logFile: filepath.Join(c.logs, "awg-ui.log"),
+		},
+		// Агент ноды: сам звонит в core и исполняет запросы на локальном awg-ctrl.
+		"agent": {
+			name: "agent", label: "awg-agent", cwd: filepath.Join(c.root, "awg-agent"), legacy: "index.ts",
+			env: [][2]string{
+				{"CORE_HOST", env("CORE_HOST", "")},
+				{"CORE_PORT", env("CORE_PORT", "")},
+				{"CORE_PIN", env("CORE_PIN", "")},
+				{"NODE_ID", env("NODE_ID", "")},
+				{"NODE_KEY_FILE", env("NODE_KEY_FILE", "/etc/amnezia/amneziawg/node.key")},
+				{"JOIN_SECRET", env("JOIN_SECRET", "")},
+				{"CLI_ENV_FILE", cliEnv},
+				{"AWGCTRL_PORT", env("AWGCTRL_PORT", "3005")},
+				{"INTERNAL_AUTH_KEY_FILE", env("INTERNAL_AUTH_KEY_FILE", "/etc/amnezia/amneziawg/internal_auth_private.key")},
+			},
+			pidFile: "/tmp/awg-agent.pid", logFile: filepath.Join(c.logs, "awg-agent.log"),
+		},
+	}
+
+	// Роль установки. node — VPN-сервер без панели (есть CORE_HOST, его пишет `join`); core с
+	// LOCAL_NODE=off — панель без своего VPN; иначе — обычная установка. Нода со своей панелью
+	// (join без --no-panel) держит и awg-ui: обе панели ходят в один awg-ctrl.
+	c.isNode = coreHost != ""
+	noLocal := strings.ToLower(env("LOCAL_NODE", "on")) == "off"
+	nodePanel := c.isNode && os.Getenv("UI_PASS") != "" && strings.ToLower(env("NODE_PANEL", "on")) != "off"
+	switch {
+	case c.isNode && nodePanel:
+		c.all = []string{"awgctrl", "ui", "agent"}
+	case c.isNode:
+		c.all = []string{"awgctrl", "agent"}
+	case noLocal:
+		c.all = []string{"ui"}
+	default:
+		c.all = []string{"awgctrl", "ui"}
+	}
+	return c
+}
+
+func (c *CLI) envOf(name string) string {
+	for _, kv := range c.svc[name].env {
+		if kv[0] == "PORT" {
+			return kv[1]
+		}
+	}
+	return ""
+}
+
+func (c *CLI) svcEnv(name, key string) string {
+	for _, kv := range c.svc[name].env {
+		if kv[0] == key {
+			return kv[1]
+		}
+	}
+	return ""
+}
+
+// ── Процессы ────────────────────────────────────────────────────────────────
+
+func (c *CLI) readPid(name string) int {
+	raw, err := os.ReadFile(c.svc[name].pidFile)
+	if err != nil {
+		return 0
+	}
+	n, err := strconv.Atoi(firstInt(strings.TrimSpace(string(raw))))
+	if err != nil {
+		return 0
+	}
+	return n
+}
+
+var reLeadInt = regexp.MustCompile(`^[+-]?\d+`)
+
+// firstInt — parseInt: ведущее целое, остальное игнорируется.
+func firstInt(s string) string { return reLeadInt.FindString(s) }
+
+// isAlive — EPERM: процесс есть, просто не наш (считаем живым).
+func isAlive(pid int) bool {
+	if pid <= 0 {
+		return false
+	}
+	err := syscall.Kill(pid, 0)
+	return err == nil || errors.Is(err, syscall.EPERM)
+}
+
+// pidMatches — защита от переиспользования PID: сверяем cmdline с сервисом. Узнаём и Go-сервис
+// (`awg-control <роль>`), и процесс Node-версии (entry-файл в cmdline). Без procfs проверить нечем.
+func (c *CLI) pidMatches(name string, pid int) bool {
+	raw, err := os.ReadFile(fmt.Sprintf("/proc/%d/cmdline", pid))
+	if err != nil {
+		return true
+	}
+	args := strings.Split(strings.TrimRight(string(raw), "\x00"), "\x00")
+	s := c.svc[name]
+	if len(args) >= 2 && filepath.Base(args[0]) == filepath.Base(c.exe) && args[1] == s.name {
+		return true
+	}
+	// tsx запускается из node_modules сервиса: путь различает index.ts awg-ctrl и awg-agent.
+	return strings.Contains(string(raw), s.legacy) && strings.Contains(string(raw), filepath.Base(s.cwd))
+}
+
+func (c *CLI) isRunning(name string) bool {
+	pid := c.readPid(name)
+	return pid != 0 && isAlive(pid) && c.pidMatches(name, pid)
+}
+
+func (c *CLI) start(name string) {
+	s := c.svc[name]
+	if c.isRunning(name) {
+		fmt.Printf("  %s: already running  pid=%d\n", s.label, c.readPid(name))
+		return
+	}
+	if name == "awgctrl" {
+		if f := c.svcEnv("awgctrl", "INTERNAL_AUTH_PUB_FILE"); !exists(f) {
+			errorf("  awgctrl: публичный ключ внутренней авторизации не найден: %s", f)
+			os.Exit(1)
+		}
+	}
+	logF, err := os.OpenFile(s.logFile, os.O_APPEND|os.O_CREATE|os.O_WRONLY, 0o644)
+	if err != nil {
+		errorf("  %s: не удалось запустить — %v", s.label, err)
+		return
+	}
+	defer logF.Close() // дескриптор унаследован ребёнком — родителю не нужен
+	cmd := exec.Command(c.exe, s.name)
+	cmd.Dir = s.cwd
+	if !exists(s.cwd) {
+		cmd.Dir = c.root
+	}
+	cmd.Env = os.Environ()
+	for _, kv := range s.env {
+		cmd.Env = append(cmd.Env, kv[0]+"="+kv[1])
+	}
+	cmd.Stdout, cmd.Stderr = logF, logF
+	cmd.SysProcAttr = &syscall.SysProcAttr{Setsid: true} // detached: переживает CLI
+	if err := cmd.Start(); err != nil {
+		errorf("  %s: не удалось запустить — %v", s.label, err)
+		os.Remove(s.pidFile)
+		return
+	}
+	go cmd.Wait() // пока CLI жив (меню), не оставляем зомби
+	os.WriteFile(s.pidFile, []byte(strconv.Itoa(cmd.Process.Pid)), 0o644)
+	fmt.Printf("  %s %s: started  pid=%d\n", green("▶"), s.label, cmd.Process.Pid)
+}
+
+func (c *CLI) stop(name string) {
+	s := c.svc[name]
+	pid := c.readPid(name)
+	if pid == 0 || !isAlive(pid) || !c.pidMatches(name, pid) {
+		fmt.Printf("  %s: not running\n", s.label)
+		os.Remove(s.pidFile)
+		return
+	}
+	syscall.Kill(pid, syscall.SIGTERM)
+	// Ждём мягкого завершения до 5 с, иначе добиваем SIGKILL.
+	deadline := time.Now().Add(5 * time.Second)
+	for isAlive(pid) && !isZombie(pid) && time.Now().Before(deadline) {
+		time.Sleep(100 * time.Millisecond)
+	}
+	if isAlive(pid) && !isZombie(pid) {
+		syscall.Kill(pid, syscall.SIGKILL)
+		time.Sleep(200 * time.Millisecond)
+	}
+	os.Remove(s.pidFile)
+	fmt.Printf("  %s %s: stopped  pid=%d\n", grey("■"), s.label, pid)
+}
+
+// isZombie — процесс завершился, но его ещё не забрал родитель (наш же Wait в меню).
+func isZombie(pid int) bool {
+	raw, err := os.ReadFile(fmt.Sprintf("/proc/%d/stat", pid))
+	if err != nil {
+		return false
+	}
+	s := string(raw)
+	if i := strings.LastIndex(s, ")"); i >= 0 && i+2 < len(s) {
+		return s[i+2] == 'Z'
+	}
+	return false
+}
+
+// fetchHealth — GET /health и разбор JSON. Любая ошибка — nil.
+func fetchHealth(url string) any {
+	cl := &http.Client{Timeout: time.Second, Transport: &http.Transport{Proxy: nil}}
+	resp, err := cl.Get(url)
+	if err != nil {
+		return nil
+	}
+	defer resp.Body.Close()
+	var b strings.Builder
+	buf := make([]byte, 4096)
+	for {
+		n, err := resp.Body.Read(buf)
+		b.WriteString(string(buf[:n]))
+		if err != nil {
+			break
+		}
+	}
+	v, err := jsjson.Decode([]byte(b.String()))
+	if err != nil {
+		return nil
+	}
+	return v
+}
+
+func get(v any, keys ...string) any {
+	for _, k := range keys {
+		o, ok := v.(jsjson.Object)
+		if !ok {
+			return nil
+		}
+		v = o.Get2(k)
+	}
+	return v
+}
+
+func strOr(v any, def string) string {
+	if s, ok := v.(string); ok && s != "" {
+		return s
+	}
+	return def
+}
+
+func (c *CLI) serviceLine(name string, menu bool) string {
+	running := c.isRunning(name)
+	dot, info := grey("○"), grey("stopped")
+	if running {
+		dot = green("●")
+		if menu {
+			info = green("running") + dim(fmt.Sprintf("  pid %d", c.readPid(name)))
+		} else {
+			info = green("running") + fmt.Sprintf("  pid %d", c.readPid(name))
+		}
+	}
+	return fmt.Sprintf("  %s %-12s %s", dot, c.svc[name].label, info)
+}
+
+func (c *CLI) status() {
+	fmt.Println()
+	for _, n := range c.all {
+		fmt.Println(c.serviceLine(n, false))
+	}
+	if c.isRunning("awgctrl") {
+		h := fetchHealth("http://127.0.0.1:" + c.envOf("awgctrl") + "/health")
+		if gen, ok := get(h, "gen").(string); ok && gen != "" {
+			g := "2.0"
+			if gen == "3.1" {
+				g = "3.1"
+			}
+			fmt.Println("  " + dim(fmt.Sprintf("AmneziaWG %s · модуль %s · tools %s", g, strOr(get(h, "awg", "module"), "?"), strOr(get(h, "awg", "tools"), "?"))))
+		}
+	}
+	fmt.Println()
+}
+
+// probe — любой HTTP-ответ (даже 401/503) значит, что порт слушается.
+func probe(url string) bool {
+	cl := &http.Client{Timeout: time.Second, Transport: &http.Transport{Proxy: nil}}
+	resp, err := cl.Get(url)
+	if err != nil {
+		return false
+	}
+	resp.Body.Close()
+	return true
+}
+
+// waitForHealth — ждём, пока awg-ctrl начнёт отвечать; умер — сразу выходим.
+func (c *CLI) waitForHealth() bool {
+	url := "http://127.0.0.1:" + c.envOf("awgctrl") + "/health"
+	for range 10 {
+		if !c.isRunning("awgctrl") {
+			return false
+		}
+		if probe(url) {
+			return true
+		}
+		time.Sleep(300 * time.Millisecond)
+	}
+	return false
+}
+
+func (c *CLI) startAll() {
+	// Панель без своего VPN: awg-ctrl рядом нет, health-gate не нужен.
+	if !contains(c.all, "awgctrl") {
+		for _, n := range c.all {
+			c.start(n)
+		}
+		return
+	}
+	c.start("awgctrl")
+	var rest, labels []string
+	for _, n := range c.all {
+		if n != "awgctrl" {
+			rest = append(rest, n)
+			labels = append(labels, c.svc[n].label)
+		}
+	}
+	if !c.isRunning("awgctrl") || !c.waitForHealth() {
+		errorf("  %s awg-ctrl не отвечает — %s не запущен (см. %s)", grey("■"), strings.Join(labels, ", "), c.svc["awgctrl"].logFile)
+		return
+	}
+	for _, n := range rest {
+		c.start(n)
+	}
+}
+
+func (c *CLI) stopAll() {
+	for _, n := range c.all {
+		c.stop(n)
+	}
+}
+
+func (c *CLI) restartAll() {
+	c.stopAll()
+	c.startAll()
+}
+
+func contains(s []string, v string) bool {
+	for _, x := range s {
+		if x == v {
+			return true
+		}
+	}
+	return false
+}
+
+// ── cli.env ─────────────────────────────────────────────────────────────────
+
+func updateEnvVar(content, key, value string) string {
+	re := regexp.MustCompile(`(?m)^` + regexp.QuoteMeta(key) + `=.*$`)
+	if loc := re.FindStringIndex(content); loc != nil {
+		return content[:loc[0]] + key + "=" + value + content[loc[1]:]
+	}
+	return strings.TrimRightFunc(content, func(r rune) bool { return r == ' ' || r == '\n' || r == '\t' || r == '\r' }) + "\n" + key + "=" + value + "\n"
+}
+
+func removeEnvVar(content, key string) string {
+	var kept []string
+	for _, l := range strings.Split(content, "\n") {
+		if !strings.HasPrefix(l, key+"=") {
+			kept = append(kept, l)
+		}
+	}
+	return strings.Join(kept, "\n")
+}
+
+func (c *CLI) readEnvFile() string {
+	raw, _ := os.ReadFile(c.envFile)
+	return string(raw)
+}
+
+// writeEnvFile — новый файл с правами 0600 (в нём пароль панели); у существующего права не трогаем.
+func (c *CLI) writeEnvFile(content string) error {
+	return os.WriteFile(c.envFile, []byte(content), 0o600)
+}
+
+// restartFresh — роль читается из окружения при старте процесса, поэтому после смены cli.env
+// перезапуск — свежим процессом с исходным окружением (без значений из старого cli.env).
+func (c *CLI) restartFresh() {
+	cmd := exec.Command(c.exe, "restart")
+	cmd.Env = c.origEnv
+	cmd.Stdin, cmd.Stdout, cmd.Stderr = os.Stdin, os.Stdout, os.Stderr
+	cmd.Run()
+}
+
+// ── Ввод ────────────────────────────────────────────────────────────────────
+
+func (c *CLI) ask(prompt string) string {
+	fmt.Print(prompt)
+	line, _ := c.in.ReadString('\n')
+	return strings.TrimRight(line, "\r\n")
+}
+
+var reYes = regexp.MustCompile(`(?i)^y`)
+
+func (c *CLI) confirmYes(q string) bool {
+	return reYes.MatchString(strings.TrimSpace(c.ask(q + " [y/N] ")))
+}
+
+// ── Точка входа ─────────────────────────────────────────────────────────────
+
+const usage = "Usage: cli <start|stop|restart|status|credentials [user|pass]|join <awgjoin://…> [--no-panel]|unjoin|peers [drop <область>]|monitor <install|status|remove>>"
+
+// Commands — команды оператора; main передаёт сюда всё, что не роль сервиса.
+var Commands = []string{"start", "stop", "restart", "status", "credentials", "join", "unjoin", "peers", "monitor"}
+
+// Main выполняет команду CLI (args — без имени бинарника). Пусто — интерактивное меню.
+func Main(args []string) {
+	c := New()
+	if len(args) == 0 {
+		c.interactiveMenu()
+		return
+	}
+	arg := func(i int) (string, bool) {
+		if i < len(args) {
+			return args[i], true
+		}
+		return "", false
+	}
+	sub, hasSub := arg(1)
+	a2, hasA2 := arg(2)
+	switch args[0] {
+	case "start":
+		c.startAll()
+	case "stop":
+		c.stopAll()
+	case "restart":
+		c.restartAll()
+	case "status":
+		c.status()
+	case "credentials":
+		switch sub {
+		case "user", "pass":
+			c.setCredentials(sub)
+		default:
+			c.setCredentials("")
+		}
+	case "join":
+		c.joinCore(sub, hasSub, a2, hasA2)
+	case "unjoin":
+		c.unjoinCore()
+	case "peers":
+		c.peersCmd(sub, hasSub, a2, hasA2)
+	case "monitor":
+		c.monitorCmd(sub)
+	default:
+		fmt.Println(usage)
+		os.Exit(1)
+	}
+}

internal/cli/cli_test.go

@@ -0,0 +1,44 @@
+package cli
+
+import "testing"
+
+func TestUpdateEnvVar(t *testing.T) {
+	for _, c := range []struct{ in, key, val, want string }{
+		{"", "A", "1", "\nA=1\n"},
+		{"A=0\nB=2\n", "A", "1", "A=1\nB=2\n"},
+		{"B=2\n\n\n", "A", "1", "B=2\nA=1\n"},
+		{"XA=0\nA=0\n", "A", "$&1", "XA=0\nA=$&1\n"},
+		{"A=0\nA=9\n", "A", "1", "A=1\nA=9\n"}, // как String.replace без g — только первое
+	} {
+		if got := updateEnvVar(c.in, c.key, c.val); got != c.want {
+			t.Errorf("updateEnvVar(%q, %s, %s) = %q, want %q", c.in, c.key, c.val, got, c.want)
+		}
+	}
+	if got := removeEnvVar("A=1\nJOIN_SECRET=x\nB=2\n", "JOIN_SECRET"); got != "A=1\nB=2\n" {
+		t.Errorf("removeEnvVar: %q", got)
+	}
+}
+
+func TestAreaOf(t *testing.T) {
+	for owner, want := range map[string]string{
+		"abcdef123456/m1/d2": "abcdef123456",
+		"m1/d2":              "legacy",
+		"alice":              "",
+		"ABCDEF123456/m1/d2": "",
+		"abc/m1/d2":          "",
+		"":                   "",
+	} {
+		if got := areaOf(owner); got != want {
+			t.Errorf("areaOf(%q) = %q, want %q", owner, got, want)
+		}
+	}
+}
+
+func TestPeersWord(t *testing.T) {
+	for n, want := range map[int]string{0: "пиров", 1: "пир", 2: "пира", 4: "пира", 5: "пиров", 11: "пиров", 12: "пиров",
+		21: "пир", 22: "пира", 101: "пир", 111: "пиров", 114: "пиров", 1004: "пира"} {
+		if got := peersWord(n); got != want {
+			t.Errorf("peersWord(%d) = %s, want %s", n, got, want)
+		}
+	}
+}

internal/cli/cmds.go

@@ -0,0 +1,486 @@
+package cli
+
+import (
+	"bytes"
+	"crypto/rand"
+	"encoding/base64"
+	"fmt"
+	"io"
+	"net/http"
+	"os"
+	"path/filepath"
+	"regexp"
+	"strings"
+	"time"
+
+	"github.com/maeneko/forgetting/internal/iauth"
+	"github.com/maeneko/forgetting/internal/jsjson"
+)
+
+var b64url = base64.RawURLEncoding
+
+// fromB64url — Buffer.from(s, "base64url"): нестрого, как в Node.
+func fromB64url(s string) []byte {
+	s = strings.NewReplacer("+", "-", "/", "_").Replace(strings.TrimRight(s, "="))
+	if len(s)%4 == 1 {
+		s = s[:len(s)-1]
+	}
+	b, _ := b64url.DecodeString(s)
+	return b
+}
+
+// ── join / unjoin ───────────────────────────────────────────────────────────
+
+var (
+	reJoinHost = regexp.MustCompile(`^[A-Za-z0-9.:_-]{1,253}$`)
+	reJoinPin  = regexp.MustCompile(`^[A-Za-z0-9_-]{43}$`)
+	reJoinSec  = regexp.MustCompile(`^[A-Za-z0-9_-]{22}$`)
+)
+
+func isPosInt(v any, max float64) (int64, bool) {
+	f, ok := v.(float64)
+	return int64(f), ok && f == float64(int64(f)) && f > 0 && f < max
+}
+
+// joinCore — `join <awgjoin://…> [--no-panel]`: подключить эту установку к главной панели как
+// ноду. Рядом запускается агент; awg-ctrl и пользователи остаются как были. Своя панель
+// продолжает работать, если она здесь есть, — с --no-panel она останавливается.
+func (c *CLI) joinCore(link string, hasLink bool, flag string, hasFlag bool) {
+	if !hasLink || !strings.HasPrefix(link, "awgjoin://") || hasFlag && flag != "--no-panel" {
+		errorf("  Usage: awg-ctrl join <awgjoin://…> [--no-panel]   (ссылку даёт панель: «Добавить сервер»)")
+		os.Exit(1)
+	}
+	v, err := jsjson.Decode(fromB64url(link[len("awgjoin://"):]))
+	j, isObj := v.(jsjson.Object)
+	if err != nil || !isObj {
+		errorf("  Ссылка повреждена")
+		os.Exit(1)
+	}
+	h, hok := j.Get2("h").(string)
+	pin, pinok := j.Get2("pin").(string)
+	sec, sok := j.Get2("s").(string)
+	port, pok := isPosInt(j.Get2("p"), 65536)
+	id, iok := isPosInt(j.Get2("n"), 9007199254740992)
+	if j.Get2("v") != 1.0 || !hok || !reJoinHost.MatchString(h) || !pok || !pinok || !reJoinPin.MatchString(pin) ||
+		!iok || !sok || !reJoinSec.MatchString(sec) {
+		errorf("  Ссылка неверного формата или от другой версии панели")
+		os.Exit(1)
+	}
+	if c.isNode && !c.confirmYes(fmt.Sprintf("  Эта нода уже подключена к %s. Перепривязать?", os.Getenv("CORE_HOST"))) {
+		return
+	}
+
+	hasPanel := os.Getenv("UI_PASS") != ""
+	keepPanel := !hasFlag && hasPanel
+	content := c.readEnvFile()
+	np := "off"
+	if keepPanel {
+		np = "on"
+	}
+	for _, kv := range [][2]string{{"CORE_HOST", h}, {"CORE_PORT", fmt.Sprint(port)}, {"CORE_PIN", pin}, {"NODE_ID", fmt.Sprint(id)},
+		{"JOIN_SECRET", sec}, {"NODE_PANEL", np}} {
+		content = updateEnvVar(content, kv[0], kv[1])
+	}
+	c.writeEnvFile(content)
+
+	// Панель останавливается, а пиры её устройств остаются на awg-ctrl — управлять ими больше
+	// некому. Решает оператор; спрашиваем до остановки, снимаем после (иначе панель вернёт их).
+	dropPeers := !keepPanel && hasPanel && c.askDropPanelPeers()
+	if !keepPanel {
+		c.stop("ui")
+	}
+	if dropPeers {
+		c.dropArea(c.localPanelID())
+	}
+	tail := ""
+	if keepPanel {
+		tail = " · своя панель продолжает работать"
+	} else if hasPanel {
+		tail = " · своя панель остановлена"
+	}
+	fmt.Printf("\n  %s Настроено: core %s:%d, нода #%d%s\n", green("✓"), h, port, id, tail)
+	c.restartFresh()
+}
+
+func (c *CLI) unjoinCore() {
+	if !c.isNode {
+		fmt.Println("  Эта установка не подключена к core")
+		return
+	}
+	c.stop("agent")
+	content := c.readEnvFile()
+	for _, k := range []string{"CORE_HOST", "CORE_PORT", "CORE_PIN", "NODE_ID", "JOIN_SECRET", "NODE_PANEL"} {
+		content = removeEnvVar(content, k)
+	}
+	c.writeEnvFile(content)
+	fmt.Printf("  %s Нода отвязана. Удалите её в панели (сервер) и запустите: awg-ctrl restart\n", green("✓"))
+	// Нода, поставленная install.sh с ролью «нода», панели не имеет — без пароля в неё не войти.
+	if os.Getenv("UI_PASS") == "" {
+		fmt.Println("  " + dim("Панель на этой машине не настроена: задайте логин и пароль — awg-ctrl credentials"))
+	}
+}
+
+// ── Пиры подписки (sen://) на локальном awg-ctrl ────────────────────────────
+// Пира ставит панель, owner = «<id панели>/m<ключ>/d<устройство>»: id — область панели. Пиры
+// без области («m1/d2») выданы до областей. Здесь — ручной рычаг для оператора: панель
+// выключена или core пропал насовсем. По времени ничего не удаляется.
+
+var (
+	reArea        = regexp.MustCompile(`^[a-z0-9]{8,16}$`)
+	reLegacyOwner = regexp.MustCompile(`^m\d+/d\d+$`)
+)
+
+func (c *CLI) localPanelID() string {
+	raw, err := os.ReadFile(filepath.Join(c.root, "awg-ui", "panel.id"))
+	if err != nil {
+		return ""
+	}
+	if id := strings.TrimSpace(string(raw)); reArea.MatchString(id) {
+		return id
+	}
+	return ""
+}
+
+type ctrlResp struct {
+	status int
+	data   any
+}
+
+// ctrlCall — запрос к локальному awg-ctrl с тем же короткоживущим токеном, что у панели и агента.
+func (c *CLI) ctrlCall(method, path string, body any) (*ctrlResp, error) {
+	key, err := iauth.LoadPrivate(c.svcEnv("ui", "INTERNAL_AUTH_KEY_FILE"))
+	if err != nil {
+		return nil, err
+	}
+	var rd io.Reader
+	if body != nil {
+		rd = bytes.NewReader(jsjson.MustMarshal(body))
+	}
+	req, err := http.NewRequest(method, "http://127.0.0.1:"+c.envOf("awgctrl")+path, rd)
+	if err != nil {
+		return nil, err
+	}
+	req.Header.Set("Authorization", "Bearer "+iauth.Mint(key, "awg-cli", time.Now()))
+	req.Header.Set("Content-Type", "application/json")
+	cl := &http.Client{Timeout: 30 * time.Second, Transport: &http.Transport{Proxy: nil}}
+	resp, err := cl.Do(req)
+	if err != nil {
+		return nil, err
+	}
+	defer resp.Body.Close()
+	raw, _ := io.ReadAll(resp.Body)
+	data, err := jsjson.Decode(raw)
+	if err != nil {
+		data = nil
+	}
+	return &ctrlResp{resp.StatusCode, data}, nil
+}
+
+type ctrlPeer struct {
+	pub, ip, owner string
+	online         bool
+}
+
+func ctrlError(r *ctrlResp) error {
+	if e, ok := get(r.data, "error").(string); ok {
+		return fmt.Errorf("%s", e)
+	}
+	return fmt.Errorf("awg-ctrl ответил %d", r.status)
+}
+
+func (c *CLI) listPeers() ([]ctrlPeer, error) {
+	r, err := c.ctrlCall("GET", "/api/peers", nil)
+	if err != nil {
+		return nil, err
+	}
+	if r.status != 200 {
+		return nil, ctrlError(r)
+	}
+	var out []ctrlPeer
+	list, _ := get(r.data, "peers").([]any)
+	for _, p := range list {
+		on, _ := get(p, "online").(bool)
+		out = append(out, ctrlPeer{pub: strOr(get(p, "pub_key"), ""), ip: strOr(get(p, "ip"), ""), owner: strOr(get(p, "owner"), ""), online: on})
+	}
+	return out, nil
+}
+
+// areaOf — область пира: id панели, «legacy» (до областей) или "" (чужой формат — не наш).
+func areaOf(owner string) string {
+	head := strings.SplitN(owner, "/", 2)[0]
+	if strings.Contains(owner, "/") && reArea.MatchString(head) {
+		return head
+	}
+	if reLegacyOwner.MatchString(owner) {
+		return "legacy"
+	}
+	return ""
+}
+
+func peersWord(n int) string {
+	switch {
+	case n%10 == 1 && n%100 != 11:
+		return "пир"
+	case n%10 >= 2 && n%10 <= 4 && !(n%100 >= 12 && n%100 <= 14):
+		return "пира"
+	}
+	return "пиров"
+}
+
+func (c *CLI) askDropPanelPeers() bool {
+	own := c.localPanelID()
+	if own == "" {
+		return false
+	}
+	peers, err := c.listPeers()
+	if err != nil {
+		fmt.Fprintln(os.Stderr, "  "+dim("Не удалось посмотреть пиров подписки: "+err.Error()))
+		return false
+	}
+	n := 0
+	for _, p := range peers {
+		if areaOf(p.owner) == own {
+			n++
+		}
+	}
+	if n == 0 {
+		return false
+	}
+	switch strings.ToLower(os.Getenv("NODE_PEERS")) {
+	case "keep":
+		return false
+	case "drop":
+		return true
+	}
+	fmt.Printf("\n  На этой панели %d %s подписки (устройства мастер-ключей). Без панели ими некому управлять:\n", n, peersWord(n))
+	fmt.Println("    1) Оставить — продолжат работать, отозвать их можно будет только после unjoin")
+	fmt.Println("    2) Отключить — снять их с VPN (ключи останутся в ui.db и вернутся после unjoin)")
+	return strings.TrimSpace(c.ask("  Выбор [1]: ")) == "2"
+}
+
+// dropArea — снять всю область: для панели — пустым списком через sync, для legacy — по одному.
+func (c *CLI) dropArea(area string) {
+	if area == "legacy" {
+		peers, err := c.listPeers()
+		if err != nil {
+			errorf("  Не удалось снять пиров: %v", err)
+			return
+		}
+		n := 0
+		for _, p := range peers {
+			if areaOf(p.owner) != "legacy" {
+				continue
+			}
+			if _, err := c.ctrlCall("DELETE", "/api/peers/"+b64url.EncodeToString(stdB64(p.pub)), nil); err != nil {
+				errorf("  Не удалось снять пиров: %v", err)
+				return
+			}
+			n++
+		}
+		fmt.Printf("  %s Снято пиров без области: %d\n", green("✓"), n)
+		return
+	}
+	r, err := c.ctrlCall("PUT", "/api/peers/sync", jsjson.Object{{Key: "owner", Val: area}, {Key: "keep", Val: []any{}}})
+	if err == nil && r.status != 200 {
+		err = ctrlError(r)
+	}
+	if err != nil {
+		errorf("  Не удалось снять пиров: %v", err)
+		return
+	}
+	fmt.Printf("  %s Снято пиров области %s: %s\n", green("✓"), area, jsString(get(r.data, "removed")))
+}
+
+func stdB64(s string) []byte {
+	b, err := base64.StdEncoding.DecodeString(s)
+	if err != nil {
+		return fromB64url(s)
+	}
+	return b
+}
+
+// jsString — `${v}` для вывода числа или строки из ответа.
+func jsString(v any) string {
+	switch x := v.(type) {
+	case nil:
+		return "undefined"
+	case string:
+		return x
+	case float64:
+		return jsjson.Number(x)
+	}
+	return string(jsjson.MustMarshal(v))
+}
+
+func (c *CLI) peersCmd(sub string, hasSub bool, arg string, hasArg bool) {
+	own := c.localPanelID()
+	peers, err := c.listPeers()
+	if err != nil {
+		errorf("  awg-ctrl недоступен: %v", err)
+		os.Exit(1)
+	}
+	var order []string
+	areas := map[string][]ctrlPeer{}
+	for _, p := range peers {
+		if a := areaOf(p.owner); a != "" {
+			if _, seen := areas[a]; !seen {
+				order = append(order, a)
+			}
+			areas[a] = append(areas[a], p)
+		}
+	}
+
+	if !hasSub {
+		if len(areas) == 0 {
+			fmt.Println("  Пиров подписки (sen://) на этом сервере нет")
+			return
+		}
+		fmt.Print("\n  Пиры подписки (sen://) на этом сервере:\n\n")
+		for _, a := range order {
+			list := areas[a]
+			mark := ""
+			if a == own {
+				mark = "эта панель"
+			} else if a == "legacy" {
+				mark = "без области (выданы до областей)"
+			}
+			online := 0
+			for _, p := range list {
+				if p.online {
+					online++
+				}
+			}
+			fmt.Printf("    %s %4d %-5s  онлайн %d  %s\n", bold(fmt.Sprintf("%-16s", a)), len(list), peersWord(len(list)), online, dim(mark))
+		}
+		fmt.Printf("\n  %s\n", dim("Снять область целиком: awg-ctrl peers drop <область>"))
+		return
+	}
+	if sub != "drop" || !hasArg || arg == "" || !(arg == "legacy" || reArea.MatchString(arg)) {
+		errorf("  Usage: awg-ctrl peers [drop <область|legacy>]")
+		os.Exit(1)
+	}
+	n := len(areas[arg])
+	if n == 0 {
+		fmt.Printf("  В области %s пиров нет\n", arg)
+		return
+	}
+	// Панель, которая ведёт эту область, вернёт пиров при следующем сведении — снимать бесполезно.
+	if arg == own && c.isRunning("ui") {
+		errorf("  Эту область ведёт панель на этой машине — удаляйте мастер-ключи или устройства в ней")
+		os.Exit(1)
+	}
+	fmt.Println("  " + dim("Если панель этой области ещё ведёт сервер, она вернёт пиров при следующем сведении —"))
+	fmt.Println("  " + dim("сперва удалите сервер в ней (или мастер-ключи)."))
+	if !c.confirmYes(fmt.Sprintf("  Снять %d %s области %s? Их устройства потеряют доступ к этому серверу.", n, peersWord(n), arg)) {
+		return
+	}
+	c.dropArea(arg)
+}
+
+// ── Логин и пароль панели ───────────────────────────────────────────────────
+
+func (c *CLI) setCredentials(field string) {
+	var user, pass *string
+	if field == "" || field == "user" {
+		cur := env("UI_USER", "admin")
+		u := strings.TrimSpace(c.ask(fmt.Sprintf("\n  Логин [%s]: ", cur)))
+		if u == "" {
+			u = cur
+		}
+		user = &u
+	}
+	if field == "" || field == "pass" {
+		b := make([]byte, 9)
+		rand.Read(b)
+		generated := b64url.EncodeToString(b)[:12]
+		p := strings.TrimSpace(c.ask(fmt.Sprintf("  Пароль [%s]: ", generated)))
+		if p == "" {
+			p = generated
+		}
+		pass = &p
+	}
+	content := c.readEnvFile()
+	if user != nil {
+		content = updateEnvVar(content, "UI_USER", *user)
+		os.Setenv("UI_USER", *user)
+	}
+	if pass != nil {
+		content = updateEnvVar(content, "UI_PASS", *pass)
+		os.Setenv("UI_PASS", *pass)
+	}
+	c.writeEnvFile(content)
+	if user != nil {
+		fmt.Printf("\n  %s Логин:  %s\n", green("✓"), *user)
+	}
+	if pass != nil {
+		fmt.Printf("  %s Пароль: %s\n", green("✓"), *pass)
+	}
+	fmt.Printf("\n  %s\n", dim("Перезапусти UI чтобы изменения вступили в силу."))
+}
+
+// ── Интерактивное меню ──────────────────────────────────────────────────────
+
+func clearScreen() {
+	if st, err := os.Stdout.Stat(); err == nil && st.Mode()&os.ModeCharDevice != 0 {
+		fmt.Print("\x1b[1;1H\x1b[0J")
+	}
+}
+
+func (c *CLI) interactiveMenu() {
+	printMenu := func() {
+		clearScreen()
+		var parts []string
+		for _, p := range []string{c.brand, c.channel, c.version} {
+			if p != "" {
+				parts = append(parts, p)
+			}
+		}
+		fmt.Printf("\n%s\n\n", bold(cBlue+"── "+strings.Join(parts, " ")+" ──"+cReset))
+		for _, n := range c.all {
+			fmt.Println(c.serviceLine(n, true))
+		}
+		sep := dim("──────────────")
+		fmt.Printf(`
+  %s  Запустить
+  %s  Остановить
+  %s  Перезапустить
+  %s  Статус
+  %s
+  %s  Сменить логин UI
+  %s  Сменить пароль UI
+  %s
+  %s  Выход
+
+`, bold("1"), bold("2"), bold("3"), bold("4"), sep, bold("5"), bold("6"), sep, bold("0"))
+	}
+	for {
+		printMenu()
+		fmt.Print("  › ")
+		choice, err := c.in.ReadString('\n')
+		if err != nil && choice == "" {
+			fmt.Println()
+			return // stdin закрыт
+		}
+		choice = strings.TrimSpace(choice)
+		fmt.Println()
+		switch choice {
+		case "1":
+			c.startAll()
+		case "2":
+			c.stopAll()
+		case "3":
+			c.restartAll()
+		case "4":
+			c.status()
+		case "5":
+			c.setCredentials("user")
+		case "6":
+			c.setCredentials("pass")
+		case "0":
+			os.Exit(0)
+		default:
+			fmt.Println(grey("  Неверный выбор"))
+		}
+		c.ask("\n  " + dim("Enter для продолжения..."))
+	}
+}

internal/cli/monitor.go

@@ -0,0 +1,265 @@
+package cli
+
+// `awg-ctrl monitor install|status|remove` — встроенный Prometheus для вкладки «Монитор» (порт
+// cli/src/monitor.ts). Работает от root (ставит пакет, пишет в /etc): панель сама пакетов не
+// ставит, она только просит (через awg-ctrl) или показывает эту команду. Всё слушает
+// 127.0.0.1: наружу Prometheus не торчит, а панель читает его по HTTP на той же машине.
+
+import (
+	"crypto/rand"
+	"crypto/sha256"
+	"encoding/hex"
+	"fmt"
+	"io"
+	"net/http"
+	"os"
+	"os/exec"
+	"regexp"
+	"strconv"
+	"strings"
+	"time"
+)
+
+const (
+	awgDir          = "/etc/amnezia/amneziawg"
+	promDir         = "/etc/prometheus"
+	promConf        = promDir + "/prometheus.yml"
+	promToken       = promDir + "/forgetting.token"
+	monitorHashFile = awgDir + "/monitor_token.sha256" // хэш локального токена: его читает awg-ui
+	promDefaults    = "/etc/default/prometheus"
+	promMarker      = "# managed by forgetting"
+	promListen      = "127.0.0.1:9090"
+	promRetention   = "31d" // с запасом на вид «30 дней» во вкладке «Монитор»
+)
+
+func mlog(s string) { fmt.Println("  " + s) }
+
+func mfail(s string) {
+	fmt.Fprintf(os.Stderr, "\n  ✗ %s\n\n", s)
+	os.Exit(1)
+}
+
+type shResult struct {
+	ok     bool
+	output string
+}
+
+// sh — команда без stdin; quiet — вывод забираем себе, иначе он идёт в терминал.
+func sh(quiet bool, name string, args ...string) shResult {
+	cmd := exec.Command(name, args...)
+	cmd.Env = append(os.Environ(), "DEBIAN_FRONTEND=noninteractive")
+	if quiet {
+		out, err := cmd.CombinedOutput()
+		return shResult{err == nil, string(out)}
+	}
+	cmd.Stdout, cmd.Stderr = os.Stdout, os.Stderr
+	return shResult{cmd.Run() == nil, ""}
+}
+
+var (
+	reOSID     = regexp.MustCompile(`(?m)^ID=(.*)$`)
+	reOSIDLike = regexp.MustCompile(`(?m)^ID_LIKE=(.*)$`)
+	reDebian   = regexp.MustCompile(`(?i)debian|ubuntu`)
+	rePromVer  = regexp.MustCompile(`version (\d+)\.(\d+)`)
+	reArgsLine = regexp.MustCompile(`(?m)^ARGS=.*$`)
+)
+
+func osFamily() string {
+	raw, err := os.ReadFile("/etc/os-release")
+	if err != nil {
+		return ""
+	}
+	val := func(re *regexp.Regexp) string {
+		if m := re.FindStringSubmatch(string(raw)); m != nil {
+			return strings.ReplaceAll(m[1], `"`, "")
+		}
+		return ""
+	}
+	return val(reOSID) + " " + val(reOSIDLike)
+}
+
+func promReady() bool {
+	cl := &http.Client{Timeout: 1500 * time.Millisecond, Transport: &http.Transport{Proxy: nil}}
+	resp, err := cl.Get("http://" + promListen + "/-/ready")
+	if err != nil {
+		return false
+	}
+	io.Copy(io.Discard, resp.Body)
+	resp.Body.Close()
+	return resp.StatusCode == 200
+}
+
+func promInstalled() bool { return sh(true, "dpkg", "-s", "prometheus").ok }
+func promActive() bool    { return sh(true, "systemctl", "is-active", "--quiet", "prometheus").ok }
+func promManaged() bool {
+	raw, err := os.ReadFile(promConf)
+	return err == nil && strings.Contains(string(raw), promMarker)
+}
+
+// authBlock — новые схемы (authorization.credentials_file) есть с 2.26; в 3.x bearer_token_file убран.
+func authBlock() string {
+	r := sh(true, "prometheus", "--version")
+	maj, min := 2, 0
+	if m := rePromVer.FindStringSubmatch(r.output); m != nil {
+		maj, _ = strconv.Atoi(m[1])
+		min, _ = strconv.Atoi(m[2])
+	}
+	if maj > 2 || maj == 2 && min >= 26 {
+		return "    authorization:\n      credentials_file: " + promToken + "\n"
+	}
+	return "    bearer_token_file: " + promToken + "\n"
+}
+
+// backupStamp — new Date().toISOString() с «:» и «.» → «-».
+func backupStamp() string {
+	return strings.NewReplacer(":", "-", ".", "-").Replace(time.Now().UTC().Format("2006-01-02T15:04:05.000Z"))
+}
+
+func copyFile(src, dst string) {
+	if raw, err := os.ReadFile(src); err == nil {
+		os.WriteFile(dst, raw, 0o644)
+	}
+}
+
+func writePromConfig(uiPort string) {
+	if exists(promConf) {
+		copyFile(promConf, promConf+".bak-"+backupStamp())
+	}
+	os.WriteFile(promConf, []byte(promMarker+`
+global:
+  scrape_interval: 15s
+  evaluation_interval: 15s
+
+scrape_configs:
+  - job_name: forgetting
+    scheme: http
+    metrics_path: /metrics
+`+authBlock()+`    static_configs:
+      - targets: ['127.0.0.1:`+uiPort+`']
+`), 0o644)
+}
+
+// writePromToken — токен для самого Prometheus. Файл читает пользователь prometheus, в панели лежит только хэш.
+func writePromToken() {
+	b := make([]byte, 24)
+	rand.Read(b)
+	token := "awgm_" + b64url.EncodeToString(b)
+	os.WriteFile(promToken, []byte(token), 0o640)
+	sh(true, "chown", "root:prometheus", promToken)
+	sum := sha256.Sum256([]byte(token))
+	os.WriteFile(monitorHashFile, []byte(hex.EncodeToString(sum[:])+"\n"), 0o644)
+}
+
+func setPromArgs() {
+	line := `ARGS="--web.listen-address=` + promListen + ` --storage.tsdb.retention.time=` + promRetention + `"`
+	raw, _ := os.ReadFile(promDefaults)
+	text := string(raw)
+	if text != "" {
+		copyFile(promDefaults, promDefaults+".bak-"+backupStamp())
+	}
+	if loc := reArgsLine.FindStringIndex(text); loc != nil {
+		text = text[:loc[0]] + line + text[loc[1]:]
+	} else {
+		text = strings.TrimSuffix(text, "\n") + "\n" + line + "\n"
+	}
+	os.WriteFile(promDefaults, []byte(text), 0o644)
+}
+
+func (c *CLI) monitorInstall() {
+	if os.Getuid() != 0 {
+		mfail("Нужен root: sudo awg-ctrl monitor install")
+	}
+	if !reDebian.MatchString(osFamily()) {
+		mfail("Автоустановка поддерживает только Debian и Ubuntu. На другом дистрибутиве поставьте Prometheus сами и подключите его кнопкой в панели (токен метрик).")
+	}
+	uiPort := os.Getenv("UI_PORT")
+	if uiPort == "" {
+		mfail("На этой машине нет панели (UI_PORT не задан): Prometheus скрейпит метрики панели.")
+	}
+	// Чужой Prometheus не трогаем: перезаписать его prometheus.yml значит сломать чужой мониторинг.
+	if promInstalled() && exists(promConf) && !promManaged() {
+		mfail("Prometheus уже установлен и настроен не нами (" + promConf + "). Подключите его кнопкой «Подключить Prometheus» во вкладке «Монитор»: она выдаст токен и готовый конфиг.")
+	}
+
+	mlog("1/4  установка пакета prometheus")
+	if !promInstalled() {
+		if !sh(false, "apt-get", "update", "-qq").ok {
+			mfail("apt-get update завершился ошибкой")
+		}
+		if !sh(false, "apt-get", "install", "-y", "--no-install-recommends", "prometheus").ok {
+			mfail("apt-get install prometheus завершился ошибкой")
+		}
+	} else {
+		mlog("уже установлен")
+	}
+
+	mlog("2/4  токен и конфиг")
+	writePromToken()
+	writePromConfig(uiPort)
+
+	mlog("3/4  слушаем только " + promListen + ", хранение " + promRetention)
+	setPromArgs()
+
+	mlog("4/4  запуск")
+	sh(true, "systemctl", "enable", "prometheus")
+	if !sh(false, "systemctl", "restart", "prometheus").ok {
+		mfail("prometheus не запустился: journalctl -u prometheus")
+	}
+	for range 30 {
+		if promReady() {
+			fmt.Printf("\n  ✓ Prometheus работает на %s, метрики панели скрейпятся каждые 15 с.\n    Во вкладке «Монитор» графики появятся через минуту-две.\n\n", promListen)
+			return
+		}
+		time.Sleep(time.Second)
+	}
+	mfail("Prometheus не ответил за 30 с: journalctl -u prometheus")
+}
+
+func yesNo(b bool, yes, no string) string {
+	if b {
+		return yes
+	}
+	return no
+}
+
+func monitorStatus() {
+	ok := promReady()
+	fmt.Println("  пакет:     " + yesNo(promInstalled(), "установлен", "нет"))
+	fmt.Println("  сервис:    " + yesNo(promActive(), "работает", "остановлен"))
+	fmt.Println("  наш конфиг: " + yesNo(promManaged(), "да", "нет"))
+	fmt.Println("  готов:     " + yesNo(ok, "да, "+promListen, "нет"))
+}
+
+func monitorRemove() {
+	if os.Getuid() != 0 {
+		mfail("Нужен root: sudo awg-ctrl monitor remove")
+	}
+	// Чужой Prometheus не удаляем: у него могут быть свои данные и задачи, которых мы не ставили.
+	if promInstalled() && exists(promConf) && !promManaged() {
+		mfail("Prometheus настроен не нами (" + promConf + "), поэтому панель его не удаляет. Если он не нужен: sudo apt purge prometheus")
+	}
+	mlog("1/3  остановка сервиса")
+	sh(true, "systemctl", "disable", "--now", "prometheus")
+	mlog("2/3  токен")
+	os.Remove(promToken)
+	os.Remove(monitorHashFile)
+	mlog("3/3  удаление пакета и накопленных данных")
+	if promInstalled() && !sh(false, "apt-get", "purge", "-y", "prometheus").ok {
+		mfail("apt-get purge prometheus завершился ошибкой")
+	}
+	fmt.Print("\n  ✓ Prometheus удалён вместе с накопленными графиками. Панель продолжает отдавать /metrics.\n\n")
+}
+
+func (c *CLI) monitorCmd(sub string) {
+	switch sub {
+	case "install":
+		c.monitorInstall()
+	case "status":
+		monitorStatus()
+	case "remove":
+		monitorRemove()
+	default:
+		fmt.Println("Usage: awg-ctrl monitor <install|status|remove>")
+		os.Exit(1)
+	}
+}

internal/ctrl/awg.go

@@ -0,0 +1,455 @@
+package ctrl
+
+import (
+	"bytes"
+	"context"
+	"crypto/rand"
+	"encoding/base64"
+	"errors"
+	"fmt"
+	"math"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"regexp"
+	"strconv"
+	"strings"
+	"time"
+	"unicode"
+)
+
+// ───────── запуск команд ─────────
+
+type cmdResult struct {
+	Stdout, Stderr string
+	Code           int // -1: не запустилась
+}
+
+func (r cmdResult) ok() bool { return r.Code == 0 }
+
+func runCmdIn(stdin string, name string, args ...string) cmdResult {
+	cmd := exec.Command(name, args...)
+	var so, se bytes.Buffer
+	cmd.Stdout, cmd.Stderr = &so, &se
+	if stdin != "" {
+		cmd.Stdin = strings.NewReader(stdin)
+	}
+	err := cmd.Run()
+	res := cmdResult{Stdout: so.String(), Stderr: se.String()}
+	if err != nil {
+		var ee *exec.ExitError
+		if errors.As(err, &ee) {
+			res.Code = ee.ExitCode()
+		} else {
+			res.Code = -1
+		}
+	}
+	return res
+}
+
+func runCmd(name string, args ...string) cmdResult { return runCmdIn("", name, args...) }
+
+// runShell — аналог execSync(cmd).trim(): через sh, ошибка при ненулевом коде.
+func runShell(cmd string) (string, error) {
+	r := runCmdIn("", "/bin/sh", "-c", cmd)
+	if !r.ok() {
+		return "", fmt.Errorf("Command failed: %s\n%s", cmd, r.Stderr)
+	}
+	return strings.TrimSpace(r.Stdout), nil
+}
+
+func runCtx(timeout time.Duration, name string, args ...string) (string, error) {
+	ctx, cancel := context.WithTimeout(context.Background(), timeout)
+	defer cancel()
+	var so, se bytes.Buffer
+	cmd := exec.CommandContext(ctx, name, args...)
+	cmd.Stdout, cmd.Stderr = &so, &se
+	if err := cmd.Run(); err != nil {
+		msg := strings.TrimSpace(se.String())
+		if msg == "" {
+			msg = err.Error()
+		}
+		return "", fmt.Errorf("%s %s: %s", name, strings.Join(args, " "), msg)
+	}
+	return so.String(), nil
+}
+
+// jsNumber — Number(s): пустая строка = 0, нечисло = NaN.
+func jsNumber(s string) float64 {
+	s = strings.TrimSpace(s)
+	if s == "" {
+		return 0
+	}
+	f, err := strconv.ParseFloat(s, 64)
+	if err != nil {
+		return math.NaN()
+	}
+	return f
+}
+
+// jsonStamp — new Date().toISOString().replace(/[:.]/g, "-").
+func jsonStamp(t time.Time) string {
+	t = t.UTC()
+	return t.Format("2006-01-02T15-04-05") + fmt.Sprintf("-%03dZ", t.Nanosecond()/1e6)
+}
+
+// ───────── ключи ─────────
+
+func (s *Server) generateKeys() (Keys, error) {
+	priv, err := runShell("umask 077 && awg genkey")
+	if err != nil {
+		return Keys{}, err
+	}
+	r := runCmdIn(priv, "awg", "pubkey")
+	if !r.ok() {
+		return Keys{}, errors.New("awg pubkey завершился с ошибкой")
+	}
+	psk, err := runShell("awg genpsk")
+	if err != nil {
+		return Keys{}, err
+	}
+	return Keys{Private: priv, Public: strings.TrimSpace(r.Stdout), PSK: psk}, nil
+}
+
+func (s *Server) genPSK() (string, error) { return runShell("awg genpsk") }
+
+func (s *Server) getServerPublicKey() (string, error) {
+	b, err := os.ReadFile(filepath.Join(s.confDir, "server_public.key"))
+	if err != nil {
+		return "", errors.New("server_public.key не найден")
+	}
+	return strings.TrimSpace(string(b)), nil
+}
+
+// ───────── интерфейс ─────────
+
+type peerStat struct {
+	Online        bool
+	LastHandshake float64
+	Rx, Tx        float64
+}
+
+// getPeersData: `awg show awg1 dump`, колонки [0] pub, [4] handshake, [5] rx, [6] tx.
+func (s *Server) getPeersData() map[string]peerStat {
+	out, err := runShell("awg show " + s.iface + " dump")
+	if err != nil {
+		s.log.Warn("getPeersData failed", "error", err)
+		return map[string]peerStat{}
+	}
+	res := map[string]peerStat{}
+	now := float64(time.Now().Unix())
+	lines := strings.Split(out, "\n")
+	for i := 1; i < len(lines); i++ {
+		parts := strings.Split(lines[i], "\t")
+		pub := parts[0]
+		if pub == "" {
+			continue
+		}
+		get := func(n int) float64 {
+			if n < len(parts) {
+				return jsNumber(parts[n])
+			}
+			return math.NaN() // Number(undefined)
+		}
+		hs := get(4)
+		res[pub] = peerStat{
+			Online:        hs > 0 && (now-hs) < 180,
+			LastHandshake: hs, Rx: get(5), Tx: get(6),
+		}
+	}
+	return res
+}
+
+type ifStatus struct {
+	Up        bool    `json:"up"`
+	Peers     int     `json:"peers"`
+	PublicKey *string `json:"publicKey"`
+}
+
+var (
+	rePeerLine = regexp.MustCompile(`(?m)^peer:`)
+	rePubKey   = regexp.MustCompile(`public key:\s*(.+)`)
+)
+
+func (s *Server) interfaceStatus() ifStatus {
+	r := runCmd("awg", "show", s.iface)
+	if !r.ok() {
+		return ifStatus{}
+	}
+	st := ifStatus{Up: true, Peers: len(rePeerLine.FindAllString(r.Stdout, -1))}
+	if m := rePubKey.FindStringSubmatch(r.Stdout); m != nil {
+		v := strings.TrimSpace(m[1])
+		st.PublicKey = &v
+	}
+	return st
+}
+
+func (s *Server) ensureInterfaceUp() error {
+	if !s.interfaceStatus().Up {
+		return fmt.Errorf("Interface %s is not up. Run: awg-quick up %s", s.iface, s.iface)
+	}
+	return nil
+}
+
+// readVersions: версия загруженного модуля (важнее версии на диске: интерфейс обслуживает
+// именно загруженный) и awg-tools. Вызывается на старте и при restartAwg — только тогда
+// модуль может смениться; из /health не вызывается (он без авторизации).
+func readVersions() (module, tools string) {
+	if b, err := os.ReadFile("/sys/module/amneziawg/version"); err == nil {
+		module = strings.TrimSpace(string(b))
+	} else if v, err := runShell("modinfo -F version amneziawg"); err == nil {
+		module = v
+	}
+	if v, err := runShell("awg --version"); err == nil {
+		for _, t := range strings.Fields(v) {
+			if regexp.MustCompile(`^v?\d`).MatchString(t) {
+				tools = t
+				break
+			}
+		}
+	}
+	return
+}
+
+// ───────── awg1.conf ─────────
+
+func (s *Server) confPath() string { return filepath.Join(s.confDir, s.iface+".conf") }
+
+func trimEndJS(s string) string { return strings.TrimRightFunc(s, unicode.IsSpace) }
+
+// rebuildConf пересобирает [Peer]-секции из БД; [Interface] сохраняется как есть.
+// Пиры устройств идут после users; без записей в peers вывод байт-в-байт прежний.
+func (s *Server) rebuildConf() error {
+	users, err := s.db.Query("SELECT name, ip, pub_key, psk_key FROM users")
+	if err != nil {
+		return err
+	}
+	type pr struct{ label, ip, pub, psk string }
+	var all []pr
+	for users.Next() {
+		var n, ip, pub, psk string
+		if err := users.Scan(&n, &ip, &pub, &psk); err != nil {
+			users.Close()
+			return err
+		}
+		all = append(all, pr{n, ip, pub, psk})
+	}
+	users.Close()
+	devices, err := s.peersAll()
+	if err != nil {
+		return err
+	}
+	if _, err := os.Stat(s.confPath()); err != nil {
+		return nil
+	}
+	raw, err := os.ReadFile(s.confPath())
+	if err != nil {
+		return err
+	}
+	for _, d := range devices {
+		label := d.Owner
+		if label == "" {
+			label = "device"
+		}
+		all = append(all, pr{label, d.IP, d.PubKey, d.PskKey})
+	}
+	iface := trimEndJS(pPeerSplit.Split(string(raw), 2)[0])
+	ka := s.cfg().Keepalive
+	blocks := make([]string, 0, len(all))
+	for _, u := range all {
+		blocks = append(blocks, "\n# "+u.label+"\n[Peer]\nPublicKey = "+u.pub+"\nPresharedKey = "+u.psk+
+			"\nAllowedIPs = "+u.ip+"/32\nPersistentKeepalive = "+ka)
+	}
+	if err := os.WriteFile(s.confPath(), []byte(iface+"\n"+strings.Join(blocks, "\n")+"\n"), 0o600); err != nil {
+		return err
+	}
+	s.log.Info("conf rebuilt", "peers", len(all))
+	return nil
+}
+
+var reAwgQuickOnly = regexp.MustCompile(`(?i)^\s*(Address|DNS|MTU|Table|PreUp|PostUp|PreDown|PostDown|SaveConfig)\s*=`)
+var rePrivateKeyLine = regexp.MustCompile(`^\s*PrivateKey\s*=`)
+var reInterfaceLine = regexp.MustCompile(`^\s*\[Interface\]`)
+
+// buildSyncConf готовит «stripped»-конфиг для `awg syncconf`: без awg-quick-ключей, но
+// с [Interface] и PrivateKey.
+//
+// 🛑 КРИТИЧНО: [Interface] с PrivateKey ОБЯЗАН попасть в этот конфиг. Когда syncconf
+// получал только [Peer]-блоки, AmneziaWG обнулял приватный ключ интерфейса и параметры
+// обфускации — сервер поднимался с public-key=(none), и ВСЕ клиенты отваливались.
+// PrivateKey берём из server_private.key — та же идентичность, что в server_public.key
+// (его зашивают в vpn:// ключи) и в PostUp.
+func (s *Server) buildSyncConf() (string, error) {
+	privRaw, err := os.ReadFile(s.serverPrivKeyFile)
+	if err != nil {
+		return "", err
+	}
+	priv := strings.TrimSpace(string(privRaw))
+	raw, err := os.ReadFile(s.confPath())
+	if err != nil {
+		return "", err
+	}
+	var out []string
+	replaced := false
+	for _, line := range strings.Split(string(raw), "\n") {
+		if reAwgQuickOnly.MatchString(line) {
+			continue
+		}
+		if rePrivateKeyLine.MatchString(line) {
+			out = append(out, "PrivateKey = "+priv)
+			replaced = true
+			continue
+		}
+		out = append(out, line)
+	}
+	if !replaced {
+		for i, l := range out {
+			if reInterfaceLine.MatchString(l) {
+				out = append(out[:i+1], append([]string{"PrivateKey = " + priv}, out[i+1:]...)...)
+				break
+			}
+		}
+	}
+	return strings.Join(out, "\n"), nil
+}
+
+func (s *Server) syncPeers() error {
+	if err := s.rebuildConf(); err != nil {
+		return err
+	}
+	cfg, err := s.buildSyncConf()
+	if err != nil {
+		return err
+	}
+	f, err := os.CreateTemp("", "awg_sync_*.conf") // 0600, O_EXCL, случайное имя
+	if err != nil {
+		return err
+	}
+	defer os.Remove(f.Name())
+	if _, err := f.WriteString(cfg); err != nil {
+		f.Close()
+		return err
+	}
+	f.Close()
+	if r := runCmd("awg", "syncconf", s.iface, f.Name()); !r.ok() {
+		s.log.Warn("syncPeers syncconf failed", "stderr", r.Stderr)
+	}
+	var n int
+	s.db.QueryRow("SELECT COUNT(*) AS n FROM users").Scan(&n)
+	s.log.Info("peers synced", "count", n)
+	return nil
+}
+
+// reloadAwgParams перечитывает параметры после любой правки конфига: иначе ключи
+// vpn:// собирались бы на старых параметрах — например, на 2.0 уже после перехода на 3.1.
+func (s *Server) reloadAwgParams() string {
+	p := ReadParams(s.confPath(), func(m string) { s.log.Warn(m) })
+	s.cfgMu.Lock()
+	s.c.Params = p
+	s.c.Gen = p.Gen()
+	s.c.Keepalive = keepaliveByGen[s.c.Gen]
+	g := s.c.Gen
+	s.cfgMu.Unlock()
+	s.log.Info("awg params loaded from conf", "Jc", p.Jc, "H1", p.H1, "gen", g)
+	return g
+}
+
+func (s *Server) restartAwg() error {
+	s.log.Info("AWG restart: down")
+	if r := runCmd("awg-quick", "down", s.iface); !r.ok() {
+		s.log.Warn("awg-quick down failed", "stderr", r.Stderr)
+	}
+	s.log.Info("AWG restart: up")
+	if r := runCmd("awg-quick", "up", s.iface); !r.ok() {
+		return fmt.Errorf("awg-quick up failed: %s", r.Stderr)
+	}
+	// Конфиг мог измениться, пока интерфейс лежал (переход на 3.1, ручная правка) —
+	// перечитываем ДО syncPeers: keepalive из CONFIG уходит в [Peer]-блоки.
+	gen := s.reloadAwgParams()
+	if err := s.syncPeers(); err != nil {
+		return err
+	}
+	go s.shaping.Apply() // tc-правила жили на интерфейсе, который мы только что пересоздали
+	m, t := readVersions()
+	s.cfgMu.Lock()
+	s.c.AwgModule, s.c.AwgTools = m, t
+	s.cfgMu.Unlock()
+	s.log.Info("AWG restart: done", "module", m, "tools", t, "gen", gen)
+	return nil
+}
+
+func (s *Server) startInterface() (ifStatus, error) {
+	st := s.interfaceStatus()
+	if st.Up {
+		s.log.Info("AWG already up", "peers", st.Peers)
+		return st, nil
+	}
+	if r := runCmd("awg-quick", "up", s.iface); !r.ok() {
+		return ifStatus{}, fmt.Errorf("awg-quick up failed: %s", r.Stderr)
+	}
+	if err := s.syncPeers(); err != nil {
+		return ifStatus{}, err
+	}
+	go s.shaping.Apply()
+	return s.interfaceStatus(), nil
+}
+
+// setPeer: PSK уходит во временный файл, а не в аргументы — иначе он виден в /proc/<pid>/cmdline.
+func (s *Server) setPeer(pub, psk, ip string) cmdResult {
+	f, err := os.CreateTemp("", "awg_psk_*.tmp")
+	if err != nil {
+		return cmdResult{Stderr: err.Error(), Code: -1}
+	}
+	defer os.Remove(f.Name())
+	f.WriteString(psk)
+	f.Close()
+	return runCmd("awg", "set", s.iface, "peer", pub,
+		"preshared-key", f.Name(),
+		"allowed-ips", ip+"/32",
+		"persistent-keepalive", s.cfg().Keepalive)
+}
+
+// kernelPeers — ключи пиров, стоящих в ядре (nil — не удалось спросить).
+func (s *Server) kernelPeers() map[string]bool {
+	r := runCmd("awg", "show", s.iface, "peers")
+	if !r.ok() {
+		return nil
+	}
+	set := map[string]bool{}
+	for _, l := range strings.Split(r.Stdout, "\n") {
+		if l = strings.TrimSpace(l); l != "" {
+			set[l] = true
+		}
+	}
+	return set
+}
+
+// dropFromKernel снимает пира с интерфейса и убеждается, что его там нет. Порядок во
+// всех вызывающих: сначала ядро, потом база — при отказе строка остаётся, и повторная
+// попытка (надгробие панели, следующий sync) найдёт пира.
+func (s *Server) dropFromKernel(pub string) bool {
+	r := runCmd("awg", "set", s.iface, "peer", pub, "remove")
+	if r.ok() {
+		return true
+	}
+	if left := s.kernelPeers(); left != nil && !left[pub] {
+		return true // ответ странный, но пира уже нет
+	}
+	s.log.Error("peer remove from kernel failed", "pub", pub, "stderr", r.Stderr)
+	return false
+}
+
+func randomHex(n int) string {
+	b := make([]byte, n)
+	rand.Read(b)
+	return fmt.Sprintf("%x", b)
+}
+
+func b64Std(s string) ([]byte, error) { return base64.StdEncoding.DecodeString(s) }
+func stdB64(b []byte) string          { return base64.StdEncoding.EncodeToString(b) }
+
+// lenientB64URL повторяет Buffer.from(s, "base64url") в Node: терпит паддинг, «+», «/».
+func lenientB64URL(s string) ([]byte, error) {
+	s = strings.NewReplacer("+", "-", "/", "_").Replace(strings.TrimRight(s, "="))
+	return base64.RawURLEncoding.DecodeString(s)
+}

internal/ctrl/db.go

@@ -0,0 +1,233 @@
+package ctrl
+
+import (
+	"database/sql"
+	"fmt"
+	"net/url"
+
+	_ "modernc.org/sqlite"
+)
+
+// Схема users.db — та же, что у Node-версии: существующие базы открываются как есть.
+// PRAGMA не задаём (журнал по умолчанию, без WAL); ждём блокировку 5 с, как better-sqlite3.
+
+type userRow struct {
+	Name       string `json:"name"`
+	IP         string `json:"ip"`
+	PubKey     string `json:"pub_key"`
+	VpnKey     string `json:"vpn_key"`
+	PskKey     string `json:"psk_key"`
+	KeyGen     string `json:"key_gen"`
+	VpnKeyPrev string `json:"vpn_key_prev"`
+}
+
+type peerRow struct {
+	PubKey    string
+	IP        string
+	PskKey    string
+	Owner     string
+	CreatedAt int64
+}
+
+func openDB(path string) (*sql.DB, error) {
+	dsn := "file:" + (&url.URL{Path: path}).EscapedPath() + "?_pragma=busy_timeout(5000)"
+	db, err := sql.Open("sqlite", dsn)
+	if err != nil {
+		return nil, err
+	}
+	// Один соединение: SQLite всё равно пишет по одному, а так нет «database is locked» между
+	// горутинами и Tx не конкурирует с запросами вне транзакции.
+	db.SetMaxOpenConns(1)
+	if err := initSchema(db); err != nil {
+		db.Close()
+		return nil, err
+	}
+	return db, nil
+}
+
+func initSchema(db *sql.DB) error {
+	for _, q := range []string{
+		`CREATE TABLE IF NOT EXISTS users (
+            name    TEXT PRIMARY KEY,
+            ip      TEXT NOT NULL UNIQUE,
+            pub_key TEXT NOT NULL,
+            vpn_key TEXT NOT NULL,
+            psk_key TEXT NOT NULL DEFAULT ''
+        )`,
+		"CREATE UNIQUE INDEX IF NOT EXISTS idx_users_ip ON users (ip)",
+	} {
+		if _, err := db.Exec(q); err != nil {
+			return err
+		}
+	}
+	// ALTER TABLE идемпотентным не бывает — смотрим фактический список колонок.
+	cols := map[string]bool{}
+	rows, err := db.Query("PRAGMA table_info(users)")
+	if err != nil {
+		return err
+	}
+	for rows.Next() {
+		var cid int
+		var name, typ string
+		var notnull, pk int
+		var dflt sql.NullString
+		if err := rows.Scan(&cid, &name, &typ, &notnull, &dflt, &pk); err != nil {
+			rows.Close()
+			return err
+		}
+		cols[name] = true
+	}
+	rows.Close()
+	if !cols["key_gen"] {
+		if _, err := db.Exec("ALTER TABLE users ADD COLUMN key_gen TEXT NOT NULL DEFAULT '2'"); err != nil {
+			return err
+		}
+	}
+	if !cols["vpn_key_prev"] {
+		if _, err := db.Exec("ALTER TABLE users ADD COLUMN vpn_key_prev TEXT NOT NULL DEFAULT ''"); err != nil {
+			return err
+		}
+	}
+	for _, q := range []string{
+		`CREATE TABLE IF NOT EXISTS config (
+            key   TEXT PRIMARY KEY,
+            value TEXT NOT NULL
+        )`,
+		// Пиры устройств sen://: приватного ключа здесь нет и быть не может.
+		`CREATE TABLE IF NOT EXISTS peers (
+            pub_key    TEXT PRIMARY KEY,
+            ip         TEXT NOT NULL UNIQUE,
+            psk_key    TEXT NOT NULL,
+            owner      TEXT NOT NULL DEFAULT '',
+            created_at INTEGER NOT NULL
+        )`,
+	} {
+		if _, err := db.Exec(q); err != nil {
+			return err
+		}
+	}
+	return nil
+}
+
+type queryer interface {
+	Query(query string, args ...any) (*sql.Rows, error)
+	QueryRow(query string, args ...any) *sql.Row
+	Exec(query string, args ...any) (sql.Result, error)
+}
+
+func (s *Server) getCfg(key, fallback string) string {
+	var v string
+	if err := s.db.QueryRow("SELECT value FROM config WHERE key = ?", key).Scan(&v); err != nil {
+		return fallback
+	}
+	return v
+}
+
+func (s *Server) setCfg(key, value string) {
+	if _, err := s.db.Exec("INSERT OR REPLACE INTO config (key, value) VALUES (?, ?)", key, value); err != nil {
+		s.log.Error("setCfg failed", "key", key, "error", err)
+	}
+}
+
+const userCols = "name, ip, pub_key, vpn_key, psk_key, key_gen, vpn_key_prev"
+
+func scanUsers(rows *sql.Rows) ([]userRow, error) {
+	defer rows.Close()
+	out := []userRow{}
+	for rows.Next() {
+		var u userRow
+		if err := rows.Scan(&u.Name, &u.IP, &u.PubKey, &u.VpnKey, &u.PskKey, &u.KeyGen, &u.VpnKeyPrev); err != nil {
+			return nil, err
+		}
+		out = append(out, u)
+	}
+	return out, rows.Err()
+}
+
+func (s *Server) usersAll() ([]userRow, error) {
+	rows, err := s.db.Query("SELECT " + userCols + " FROM users")
+	if err != nil {
+		return nil, err
+	}
+	return scanUsers(rows)
+}
+
+func (s *Server) userGet(name string) (*userRow, error) {
+	rows, err := s.db.Query("SELECT "+userCols+" FROM users WHERE name = ?", name)
+	if err != nil {
+		return nil, err
+	}
+	us, err := scanUsers(rows)
+	if err != nil || len(us) == 0 {
+		return nil, err
+	}
+	return &us[0], nil
+}
+
+func scanPeers(rows *sql.Rows) ([]peerRow, error) {
+	defer rows.Close()
+	out := []peerRow{}
+	for rows.Next() {
+		var p peerRow
+		if err := rows.Scan(&p.PubKey, &p.IP, &p.PskKey, &p.Owner, &p.CreatedAt); err != nil {
+			return nil, err
+		}
+		out = append(out, p)
+	}
+	return out, rows.Err()
+}
+
+func (s *Server) peersAll() ([]peerRow, error) {
+	rows, err := s.db.Query("SELECT pub_key, ip, psk_key, owner, created_at FROM peers ORDER BY created_at, rowid")
+	if err != nil {
+		return nil, err
+	}
+	return scanPeers(rows)
+}
+
+func (s *Server) peerGet(pub string) (*peerRow, error) {
+	rows, err := s.db.Query("SELECT pub_key, ip, psk_key, owner, created_at FROM peers WHERE pub_key = ?", pub)
+	if err != nil {
+		return nil, err
+	}
+	ps, err := scanPeers(rows)
+	if err != nil || len(ps) == 0 {
+		return nil, err
+	}
+	return &ps[0], nil
+}
+
+func (s *Server) userPubTaken(q queryer, pub string) (bool, error) {
+	var n int
+	if err := q.QueryRow("SELECT COUNT(*) AS n FROM users WHERE pub_key = ?", pub).Scan(&n); err != nil {
+		return false, err
+	}
+	return n > 0, nil
+}
+
+// nextIp: первый свободный 10.9.c.d (c = 0..255, d = 2..254) среди users и peers.
+func (s *Server) nextIp(q queryer, subnet string) (string, error) {
+	rows, err := q.Query("SELECT ip FROM users UNION SELECT ip FROM peers")
+	if err != nil {
+		return "", err
+	}
+	used := map[string]bool{}
+	for rows.Next() {
+		var ip string
+		if err := rows.Scan(&ip); err != nil {
+			rows.Close()
+			return "", err
+		}
+		used[ip] = true
+	}
+	rows.Close()
+	for c := 0; c <= 255; c++ {
+		for d := 2; d <= 254; d++ {
+			ip := fmt.Sprintf("%s.%d.%d", subnet, c, d)
+			if !used[ip] {
+				return ip, nil
+			}
+		}
+	}
+	return "", fmt.Errorf("Подсеть заполнена")
+}

internal/ctrl/helpers.go

@@ -0,0 +1,118 @@
+package ctrl
+
+import (
+	"math"
+	"regexp"
+	"strconv"
+	"strings"
+
+	"github.com/maeneko/forgetting/internal/jsjson"
+)
+
+var reOwner = regexp.MustCompile(`^[\w/.-]{0,64}$`)
+
+// checkPubKeyAny — checkPubKey для значения из JSON (не строка → тот же 400).
+func checkPubKeyAny(v any) (string, error) {
+	k, ok := v.(string)
+	if !ok {
+		return "", httpErr(400, "Неверный публичный ключ")
+	}
+	return checkPubKey(k)
+}
+
+func checkPubKeys(arr []any) ([]string, error) {
+	out := make([]string, 0, len(arr))
+	for _, v := range arr {
+		k, err := checkPubKeyAny(v)
+		if err != nil {
+			return nil, err
+		}
+		out = append(out, k)
+	}
+	return out, nil
+}
+
+// jsToNumber — Number(v) для значений из JSON.
+func jsToNumber(v any) float64 {
+	switch x := v.(type) {
+	case nil:
+		return 0
+	case float64:
+		return x
+	case bool:
+		if x {
+			return 1
+		}
+		return 0
+	case string:
+		return jsNumber(x)
+	}
+	return math.NaN()
+}
+
+func (s *Server) knownPubKeys() (map[string]bool, error) {
+	known := map[string]bool{}
+	rows, err := s.db.Query("SELECT pub_key FROM users")
+	if err != nil {
+		return nil, err
+	}
+	for rows.Next() {
+		var k string
+		rows.Scan(&k)
+		known[k] = true
+	}
+	rows.Close()
+	peers, err := s.peersAll()
+	if err != nil {
+		return nil, err
+	}
+	for _, p := range peers {
+		known[p.PubKey] = true
+	}
+	return known, nil
+}
+
+func (s *Server) isKnownPub(k string) (bool, error) {
+	if p, err := s.peerGet(k); err != nil || p != nil {
+		return p != nil, err
+	}
+	var n int
+	if err := s.db.QueryRow("SELECT COUNT(*) FROM users WHERE pub_key = ?", k).Scan(&n); err != nil {
+		return false, err
+	}
+	return n > 0, nil
+}
+
+// profileAwg — параметры для /api/profile в порядке CONFIG.awgParams (порядок объявления в
+// DEFAULT_AWG_PARAMS), без пустых значений; числа — строками.
+func profileAwg(p Params) jsjson.Object {
+	o := jsjson.Object{}
+	add := func(k, v string) {
+		if v != "" {
+			o = append(o, jsjson.KV{Key: k, Val: v})
+		}
+	}
+	itoa := strconv.Itoa
+	add("Jc", itoa(p.Jc))
+	add("Jmin", itoa(p.Jmin))
+	add("Jmax", itoa(p.Jmax))
+	add("S1", itoa(p.S1))
+	add("S2", itoa(p.S2))
+	add("S3", itoa(p.S3))
+	add("S4", itoa(p.S4))
+	add("H1", p.H1)
+	add("H2", p.H2)
+	add("H3", p.H3)
+	add("H4", p.H4)
+	add("I1", p.I1)
+	add("I2", p.I2)
+	add("I3", p.I3)
+	add("I4", p.I4)
+	add("I5", p.I5)
+	for _, k := range AWG3Keys {
+		add(k, p.A3[k])
+	}
+	return o
+}
+
+var _ = strings.TrimSpace

internal/ctrl/http.go

@@ -0,0 +1,236 @@
+package ctrl
+
+import (
+	"fmt"
+	"io"
+	"mime"
+	"net/http"
+	"regexp"
+	"strings"
+	"unicode"
+
+	"github.com/maeneko/forgetting/internal/iauth"
+	"github.com/maeneko/forgetting/internal/jsjson"
+)
+
+// Минимальный роутер с поведением Express 4, на которое опираются клиенты:
+//   - тело JSON разбирается ДО авторизации и маршрутизации (битый JSON без токена → 400, не 401);
+//   - ошибки разбора и неизвестные пути отвечают HTML, как finalhandler Express;
+//   - пути без учёта регистра и с необязательным «/» в конце; :param декодируется.
+// Первое совпавшее объявление выигрывает — порядок ниже важен («reissue» до «:name», «sync» до «:pub»).
+
+type rctx struct {
+	w      http.ResponseWriter
+	r      *http.Request
+	s      *Server
+	params map[string]string
+	body   any // jsjson.Object, []any или nil (= {})
+}
+
+type result struct {
+	status int
+	v      any
+}
+
+type route struct {
+	method string
+	segs   []string
+	mw     []func(*rctx) error
+	lock   bool
+	h      func(*rctx) (result, error)
+}
+
+const (
+	bodyLimitSmall = 1024
+	bodyLimitBig   = 512 * 1024
+)
+
+func writeJSON(w http.ResponseWriter, status int, v any) {
+	b, err := jsjson.Marshal(v)
+	if err != nil {
+		status, b = 500, []byte(`{"error":"Internal server error"}`)
+	}
+	w.Header().Set("Content-Type", "application/json; charset=utf-8")
+	w.WriteHeader(status)
+	w.Write(b)
+}
+
+func writeHTMLError(w http.ResponseWriter, status int, text string) {
+	w.Header().Set("Content-Type", "text/html; charset=utf-8")
+	w.WriteHeader(status)
+	fmt.Fprintf(w, "<!DOCTYPE html>\n<html lang=\"en\">\n<head>\n<meta charset=\"utf-8\">\n<title>Error</title>\n</head>\n<body>\n<pre>%s</pre>\n</body>\n</html>\n", text)
+}
+
+// readBody — express.json({limit}): только application/json, объект или массив.
+func readBody(r *http.Request, limit int64) (any, int, string) {
+	mt, _, _ := mime.ParseMediaType(r.Header.Get("Content-Type"))
+	if mt != "application/json" || r.ContentLength == 0 && r.Body == http.NoBody {
+		return nil, 0, ""
+	}
+	if r.ContentLength > limit {
+		return nil, 413, "PayloadTooLargeError: request entity too large"
+	}
+	raw, err := io.ReadAll(io.LimitReader(r.Body, limit+1))
+	if err != nil {
+		return nil, 400, "BadRequestError: request aborted"
+	}
+	if int64(len(raw)) > limit {
+		return nil, 413, "PayloadTooLargeError: request entity too large"
+	}
+	trimmed := strings.TrimLeftFunc(string(raw), unicode.IsSpace)
+	if trimmed == "" {
+		return nil, 0, ""
+	}
+	if trimmed[0] != '{' && trimmed[0] != '[' {
+		return nil, 400, "SyntaxError: Unexpected token in JSON"
+	}
+	v, err := jsjson.Decode(raw)
+	if err != nil {
+		return nil, 400, "SyntaxError: " + err.Error()
+	}
+	return v, 0, ""
+}
+
+func (c *rctx) obj() jsjson.Object {
+	o, _ := c.body.(jsjson.Object)
+	return o
+}
+
+func match(rt route, method string, segs []string) map[string]string {
+	if rt.method != method || len(rt.segs) != len(segs) {
+		return nil
+	}
+	params := map[string]string{}
+	for i, p := range rt.segs {
+		if strings.HasPrefix(p, ":") {
+			v, ok := unescape(segs[i])
+			if !ok {
+				return nil
+			}
+			params[p[1:]] = v
+		} else if !strings.EqualFold(p, segs[i]) {
+			return nil
+		}
+	}
+	return params
+}
+
+func unescape(s string) (string, bool) {
+	if !strings.Contains(s, "%") {
+		return s, true
+	}
+	var b strings.Builder
+	for i := 0; i < len(s); i++ {
+		if s[i] == '%' && i+2 < len(s)+0 && isHex(s[i+1]) && isHex(s[i+2]) {
+			b.WriteByte(unhex(s[i+1])<<4 | unhex(s[i+2]))
+			i += 2
+		} else if s[i] == '%' {
+			return "", false
+		} else {
+			b.WriteByte(s[i])
+		}
+	}
+	return b.String(), true
+}
+
+func isHex(c byte) bool {
+	return c >= '0' && c <= '9' || c >= 'a' && c <= 'f' || c >= 'A' && c <= 'F'
+}
+func unhex(c byte) byte {
+	switch {
+	case c >= '0' && c <= '9':
+		return c - '0'
+	case c >= 'a' && c <= 'f':
+		return c - 'a' + 10
+	}
+	return c - 'A' + 10
+}
+
+func (s *Server) handler() http.Handler {
+	routes := s.routes()
+	return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		// Тело разбирается первым и для всех путей; лимит выбирает точный путь.
+		limit := int64(bodyLimitSmall)
+		p := strings.TrimSuffix(r.URL.EscapedPath(), "/")
+		if strings.EqualFold(p, "/api/peers/sync") || strings.EqualFold(p, "/api/audit/clean") {
+			limit = bodyLimitBig
+		}
+		body, status, msg := readBody(r, limit)
+		if status != 0 {
+			writeHTMLError(w, status, msg)
+			return
+		}
+		segs := strings.Split(strings.Trim(r.URL.EscapedPath(), "/"), "/")
+		for _, rt := range routes {
+			params := match(rt, r.Method, segs)
+			if params == nil {
+				continue
+			}
+			c := &rctx{w: w, r: r, s: s, params: params, body: body}
+			s.serve(c, rt)
+			return
+		}
+		writeHTMLError(w, 404, "Cannot "+r.Method+" "+r.URL.Path)
+	})
+}
+
+func (s *Server) serve(c *rctx, rt route) {
+	defer func() {
+		if p := recover(); p != nil {
+			s.log.Error("handler panic", "error", fmt.Sprint(p))
+			writeJSON(c.w, 500, jsjson.Object{{Key: "error", Val: "Internal server error"}})
+		}
+	}()
+	for _, mw := range rt.mw {
+		if err := mw(c); err != nil {
+			s.fail(c, err)
+			return
+		}
+	}
+	if rt.lock {
+		s.mu.Lock()
+		defer s.mu.Unlock()
+	}
+	res, err := rt.h(c)
+	if err != nil {
+		s.fail(c, err)
+		return
+	}
+	writeJSON(c.w, res.status, res.v)
+}
+
+func (s *Server) fail(c *rctx, err error) {
+	if he, ok := err.(*HTTPError); ok {
+		writeJSON(c.w, he.Status, jsjson.Object{{Key: "error", Val: he.Msg}})
+		return
+	}
+	s.log.Error("handler error", "error", err)
+	writeJSON(c.w, 500, jsjson.Object{{Key: "error", Val: "Internal server error"}})
+}
+
+// ───────── middleware ─────────
+
+func (s *Server) auth(c *rctx) error {
+	h := c.r.Header.Get("Authorization")
+	tok := ""
+	if strings.HasPrefix(h, "Bearer ") {
+		tok = h[7:]
+	}
+	if tok == "" || !iauth.Verify(s.pub, tok, nowFn()) {
+		return httpErr(401, "Неверная авторизация")
+	}
+	return nil
+}
+
+var reName = regexp.MustCompile(`^[a-zA-Z0-9_-]{1,32}$`)
+
+func validateName(c *rctx) error {
+	name, ok := c.params["name"]
+	if !ok {
+		name, _ = c.obj().Get2("name").(string)
+	}
+	if name == "" || !reName.MatchString(name) {
+		return httpErr(400, "Имя: буквы, цифры, _ и -, до 32 символов")
+	}
+	return nil
+}

internal/ctrl/metrics.go

@@ -0,0 +1,189 @@
+package ctrl
+
+import (
+	"os"
+	"regexp"
+	"runtime"
+	"strconv"
+	"strings"
+	"sync"
+	"time"
+
+	"github.com/maeneko/forgetting/internal/jsjson"
+)
+
+// Метрики для Prometheus. awg-ctrl отдаёт JSON, а текстовый формат собирает awg-ui: на ноде
+// агент пропускает только /api/*, и один формат на ядре и нодах проще сверять. Кэш на 5 с —
+// несколько скрейперов не должны гонять `awg show` чаще.
+const metricsTTL = 5 * time.Second
+
+type metricsCache struct {
+	mu   sync.Mutex
+	at   time.Time
+	data any
+}
+
+type metricsPeer struct {
+	Kind     string  `json:"kind"`
+	Name     string  `json:"name"`
+	IP       string  `json:"ip"`
+	Online   bool    `json:"online"`
+	Rx       float64 `json:"rx"`
+	Tx       float64 `json:"tx"`
+	Priority string  `json:"priority"`
+	Torrent  bool    `json:"torrent"`
+}
+
+type metricsHost struct {
+	CPU   jsjson.Object `json:"cpu"` // порядок режимов как в /proc/stat (и в Node-версии)
+	Cores int           `json:"cores"`
+	Load  []float64     `json:"load"`
+	Mem   struct {
+		Total     float64 `json:"total"`
+		Available float64 `json:"available"`
+	} `json:"mem"`
+}
+
+type linkStats struct {
+	RxBytes   float64 `json:"rx_bytes"`
+	TxBytes   float64 `json:"tx_bytes"`
+	RxPackets float64 `json:"rx_packets"`
+	TxPackets float64 `json:"tx_packets"`
+	RxDropped float64 `json:"rx_dropped"`
+	TxDropped float64 `json:"tx_dropped"`
+	RxErrors  float64 `json:"rx_errors"`
+	TxErrors  float64 `json:"tx_errors"`
+}
+
+type metricsBody struct {
+	Up    bool   `json:"up"`
+	Gen   string `json:"gen"`
+	Peers struct {
+		Total  int `json:"total"`
+		Online int `json:"online"`
+	} `json:"peers"`
+	RxBytes float64       `json:"rx_bytes"`
+	TxBytes float64       `json:"tx_bytes"`
+	Link    linkStats     `json:"link"`
+	Shaping ShapingStatus `json:"shaping"`
+	Torrent TorrentStatus `json:"torrent"`
+	Host    *metricsHost  `json:"host"`
+	List    []metricsPeer `json:"list"`
+}
+
+func (s *Server) linkCounter(name string) float64 {
+	b, err := os.ReadFile("/sys/class/net/" + s.iface + "/statistics/" + name)
+	if err != nil {
+		return 0
+	}
+	return orZero(jsNumber(string(b)))
+}
+
+var cpuModes = []string{"user", "nice", "system", "idle", "iowait", "irq", "softirq", "steal"}
+
+// readHost: нагрузка хоста из /proc. Счётчики CPU кумулятивные (секунды по режимам, как у
+// node_exporter): долю считает Prometheus через rate(). Память — MemAvailable, а не MemFree:
+// кэш ядра свободен.
+func readHost() *metricsHost {
+	stat, err := os.ReadFile("/proc/stat")
+	if err != nil {
+		return nil
+	}
+	first := strings.Fields(strings.SplitN(string(stat), "\n", 2)[0])
+	if len(first) < 2 {
+		return nil
+	}
+	h := &metricsHost{Cores: runtime.NumCPU()}
+	for i, m := range cpuModes {
+		v := 0.0
+		if i+1 < len(first) {
+			v = orZero(jsNumber(first[i+1]))
+		}
+		h.CPU = append(h.CPU, jsjson.KV{Key: m, Val: v / 100}) // USER_HZ = 100 на всех обычных ядрах
+	}
+	mem, err := os.ReadFile("/proc/meminfo")
+	if err != nil {
+		return nil
+	}
+	kb := func(k string) float64 {
+		m := regexp.MustCompile(`(?m)^` + k + `:\s+(\d+) kB`).FindStringSubmatch(string(mem))
+		if m == nil {
+			return 0
+		}
+		f, _ := strconv.ParseFloat(m[1], 64)
+		return f * 1024
+	}
+	h.Mem.Total, h.Mem.Available = kb("MemTotal"), kb("MemAvailable")
+	if la, err := os.ReadFile("/proc/loadavg"); err == nil {
+		f := strings.Fields(string(la))
+		for i := 0; i < 3 && i < len(f); i++ {
+			h.Load = append(h.Load, orZero(jsNumber(f[i])))
+		}
+	}
+	return h
+}
+
+func (s *Server) collectMetrics() (*metricsBody, error) {
+	st := s.interfaceStatus()
+	stats := map[string]peerStat{}
+	if st.Up {
+		stats = s.getPeersData()
+	}
+	torrent := s.torrent.SeenSet() // до запроса: внутри цикла по строкам — ни базы, ни nft
+	rows, err := s.db.Query("SELECT name, ip, pub_key FROM users WHERE vpn_key != ''")
+	if err != nil {
+		return nil, err
+	}
+	b := &metricsBody{Up: st.Up, Gen: s.cfg().Gen, List: []metricsPeer{}}
+	for rows.Next() {
+		var n, ip, pub string
+		if err := rows.Scan(&n, &ip, &pub); err != nil {
+			rows.Close()
+			return nil, err
+		}
+		ps := stats[pub]
+		b.List = append(b.List, metricsPeer{"user", n, ip, ps.Online, orZero(ps.Rx), orZero(ps.Tx), s.shaping.PriorityOf(ip), torrent[ip]})
+	}
+	rows.Close()
+	devs, err := s.peersAll()
+	if err != nil {
+		return nil, err
+	}
+	for _, p := range devs {
+		ps := stats[p.PubKey]
+		b.List = append(b.List, metricsPeer{"device", "", p.IP, ps.Online, orZero(ps.Rx), orZero(ps.Tx), s.shaping.PriorityOf(p.IP), torrent[p.IP]})
+	}
+	b.Peers.Total = st.Peers
+	for _, ps := range stats {
+		if ps.Online {
+			b.Peers.Online++
+		}
+		b.RxBytes += orZero(ps.Rx)
+		b.TxBytes += orZero(ps.Tx)
+	}
+	b.Link = linkStats{
+		s.linkCounter("rx_bytes"), s.linkCounter("tx_bytes"), s.linkCounter("rx_packets"), s.linkCounter("tx_packets"),
+		s.linkCounter("rx_dropped"), s.linkCounter("tx_dropped"), s.linkCounter("rx_errors"), s.linkCounter("tx_errors"),
+	}
+	b.Shaping = s.shaping.Status()
+	b.Torrent = s.torrent.Status()
+	b.Host = readHost()
+	return b, nil
+}
+
+// metricsCached отдаёт кэш на metricsTTL; ошибку не кэшируем.
+func (s *Server) metricsCached() (any, error) {
+	m := &s.metrics
+	m.mu.Lock()
+	defer m.mu.Unlock()
+	if m.data != nil && time.Since(m.at) <= metricsTTL {
+		return m.data, nil
+	}
+	d, err := s.collectMetrics()
+	if err != nil {
+		m.data = nil
+		return nil, err
+	}
+	m.at, m.data = time.Now(), d
+	return d, nil
+}

internal/ctrl/metrics_test.go

@@ -0,0 +1,37 @@
+package ctrl
+
+import (
+	"fmt"
+	"os"
+	"path/filepath"
+	"testing"
+	"time"
+
+	"github.com/maeneko/forgetting/internal/logx"
+)
+
+// SQLite открыт с одним соединением: любой запрос в базу изнутри цикла по строкам users ждал
+// бы его вечно и намертво вешал awg-ctrl (так было в 0.4.2 с меткой торрента). Скрейп метрик
+// идёт раз в 15 с, поэтому зависание проявлялось сразу.
+func TestCollectMetricsNoDeadlock(t *testing.T) {
+	db, err := openDB(filepath.Join(t.TempDir(), "users.db"))
+	if err != nil {
+		t.Fatal(err)
+	}
+	for i := 0; i < 5; i++ {
+		db.Exec("INSERT INTO users (name, ip, pub_key, vpn_key) VALUES (?, ?, ?, 'vpn://x')", fmt.Sprintf("u%d", i), fmt.Sprintf("10.9.0.%d", i+2), fmt.Sprintf("pk%d", i))
+	}
+	s := &Server{db: db, iface: "awg1", log: logx.New(os.Stderr, t.TempDir())}
+	s.shaping = newShaping(s)
+	s.torrent = newTorrent(s)
+	done := make(chan error, 1)
+	go func() { _, err := s.collectMetrics(); done <- err }()
+	select {
+	case err := <-done:
+		if err != nil {
+			t.Fatal(err)
+		}
+	case <-time.After(3 * time.Second):
+		t.Fatal("collectMetrics завис: запрос в базу изнутри цикла по строкам")
+	}
+}

internal/ctrl/monitorjob.go

@@ -0,0 +1,104 @@
+package ctrl
+
+import (
+	"os"
+	"os/exec"
+	"path/filepath"
+	"regexp"
+	"strings"
+	"sync"
+)
+
+// Установка и удаление встроенного мониторинга (Prometheus) по кнопке в панели. Действие
+// одно из двух и без параметров: awg-ctrl запускает ту же команду, что оператор набрал бы
+// руками (`awg-ctrl monitor install|remove`, root), так что код один. Панель сама пакетов
+// не ставит и не удаляет — она только просит об этом здесь.
+
+type monitorJob struct {
+	mu     sync.Mutex
+	active bool
+	action string
+	exit   *int
+}
+
+var reANSI = regexp.MustCompile("\x1b\\[[0-9;]*[A-Za-z]")
+
+func (s *Server) logTail() string {
+	b, err := os.ReadFile(s.cliLog)
+	if err != nil {
+		return ""
+	}
+	t := string(b)
+	if len(t) > 4000 { // последние 4000 символов (в JS — UTF-16 единиц; для лога разницы нет)
+		t = t[len(t)-4000:]
+	}
+	return strings.ReplaceAll(reANSI.ReplaceAllString(t, ""), "\r", "\n")
+}
+
+// startMonitorJob запускает CLI в фоне; возвращает 409, если уже идёт.
+func (s *Server) startMonitorJob(action string) error {
+	j := &s.monitor
+	j.mu.Lock()
+	if j.active {
+		j.mu.Unlock()
+		return httpErr(409, "Операция уже идёт")
+	}
+	if _, err := os.Stat(s.cliPath); err != nil {
+		j.mu.Unlock()
+		return httpErr(501, "CLI не найден ("+s.cliPath+"): выполните на сервере awg-ctrl monitor "+action)
+	}
+	os.MkdirAll(filepath.Dir(s.cliLog), 0o755)
+	f, err := os.OpenFile(s.cliLog, os.O_WRONLY|os.O_CREATE|os.O_TRUNC, 0o644)
+	if err != nil {
+		j.mu.Unlock()
+		return err
+	}
+	cmd := exec.Command(s.cliPath, "monitor", action)
+	cmd.Stdout, cmd.Stderr = f, f
+	j.active, j.action, j.exit = true, action, nil
+	if err := cmd.Start(); err != nil {
+		s.log.Error("monitor: не запустился", "action", action, "error", err.Error())
+		code := 127
+		j.active, j.exit = false, &code
+		f.Close()
+		j.mu.Unlock()
+		return nil
+	}
+	j.mu.Unlock()
+	go func() {
+		err := cmd.Wait()
+		code := 0
+		if err != nil {
+			code = 1
+			if ee, ok := err.(*exec.ExitError); ok {
+				code = ee.ExitCode()
+			}
+		}
+		f.Close()
+		s.log.Info("monitor: завершён", "action", action, "code", code)
+		j.mu.Lock()
+		j.active, j.exit = false, &code
+		j.mu.Unlock()
+	}()
+	return nil
+}
+
+type jobView struct {
+	Action  *string `json:"action"`
+	Running bool    `json:"running"`
+	Exit    *int    `json:"exit"`
+	Log     string  `json:"log"`
+}
+
+func (s *Server) monitorView() jobView {
+	j := &s.monitor
+	j.mu.Lock()
+	defer j.mu.Unlock()
+	v := jobView{Running: j.active, Exit: j.exit}
+	if j.action != "" {
+		a := j.action
+		v.Action = &a
+		v.Log = s.logTail()
+	}
+	return v
+}

internal/ctrl/ops.go

@@ -0,0 +1,605 @@
+package ctrl
+
+import (
+	"errors"
+	"fmt"
+	"os"
+	"path/filepath"
+	"regexp"
+	"strconv"
+	"strings"
+	"time"
+
+	"github.com/maeneko/forgetting/internal/jsjson"
+)
+
+// HTTPError — ошибка с кодом ответа; любая другая ошибка превращается в 500.
+type HTTPError struct {
+	Status int
+	Msg    string
+}
+
+func (e *HTTPError) Error() string { return e.Msg }
+
+func httpErr(status int, msg string) error { return &HTTPError{status, msg} }
+
+// ───────── пользователи (vpn://) ─────────
+
+func (s *Server) addUser(name string) (*userRow, error) {
+	keys, err := s.generateKeys()
+	if err != nil {
+		return nil, err
+	}
+	serverPub, err := s.getServerPublicKey()
+	if err != nil {
+		return nil, err
+	}
+	cfg := s.cfg()
+
+	var ip string
+	tx, err := s.db.Begin()
+	if err != nil {
+		return nil, err
+	}
+	ip, err = s.nextIp(tx, cfg.Subnet)
+	if err == nil {
+		_, err = tx.Exec("INSERT INTO users (name, ip, pub_key, vpn_key, psk_key, key_gen) VALUES (?, ?, ?, ?, ?, ?)",
+			name, ip, keys.Public, "", keys.PSK, cfg.Gen)
+	}
+	if err != nil {
+		tx.Rollback()
+		return nil, err
+	}
+	if err := tx.Commit(); err != nil {
+		return nil, err
+	}
+
+	vpnKey, err := EncodeVpnKey(s.keyEnv(), keys, ip, serverPub)
+	if err != nil {
+		return nil, err
+	}
+	if _, err := s.db.Exec("UPDATE users SET vpn_key = ? WHERE name = ?", vpnKey, name); err != nil {
+		return nil, err
+	}
+
+	if r := s.setPeer(keys.Public, keys.PSK, ip); !r.ok() {
+		s.db.Exec("DELETE FROM users WHERE name = ?", name)
+		return nil, fmt.Errorf("awg set failed: %s", r.Stderr)
+	}
+	if err := s.rebuildConf(); err != nil {
+		return nil, err
+	}
+	s.log.Info("user created", "name", name, "ip", ip, "gen", cfg.Gen)
+	return &userRow{Name: name, IP: ip, PubKey: keys.Public, VpnKey: vpnKey, PskKey: keys.PSK, KeyGen: cfg.Gen}, nil
+}
+
+func (s *Server) removeUser(name string) error {
+	u, err := s.userGet(name)
+	if err != nil {
+		return err
+	}
+	if u == nil {
+		return errors.New("Пользователь не найден") // в Node — обычный Error → 500
+	}
+	if !s.dropFromKernel(u.PubKey) {
+		return errors.New("Не удалось снять пира с интерфейса")
+	}
+	if _, err := s.db.Exec("DELETE FROM users WHERE name = ?", name); err != nil {
+		return err
+	}
+	if err := s.rebuildConf(); err != nil {
+		return err
+	}
+	for _, ext := range []string{".conf", ".key"} {
+		f := filepath.Join(s.confDir, "clients", name+ext)
+		if _, err := os.Stat(f); err == nil {
+			os.Remove(f)
+		}
+	}
+	s.log.Info("user removed", "name", name)
+	return nil
+}
+
+type reissueResult struct {
+	Total       int      `json:"total"`
+	Reissued    int      `json:"reissued"`
+	Regenerated []string `json:"regenerated"`
+	Backup      string   `json:"backup"`
+}
+
+// reissueAll перевыпускает все vpn:// ключи на текущих параметрах интерфейса — после смены
+// поколения старые перестают работать. IP, pub_key и psk_key сохраняются: на проводе ничего
+// не меняется, клиенту достаточно заново импортировать ключ.
+func (s *Server) reissueAll() (*reissueResult, error) {
+	users, err := s.usersAll()
+	if err != nil {
+		return nil, err
+	}
+	serverPub, err := s.getServerPublicKey()
+	if err != nil {
+		return nil, err
+	}
+	backup := s.dbPath + ".bak-" + jsonStamp(time.Now())
+	if _, err := s.db.Exec("VACUUM INTO ?", backup); err != nil {
+		return nil, err
+	}
+	s.log.Info("reissue: db backed up", "backup", backup, "users", len(users))
+
+	res := &reissueResult{Total: len(users), Regenerated: []string{}, Backup: backup}
+	cfg := s.cfg()
+	for _, u := range users {
+		var keys Keys
+		if priv := clientPrivKeyFrom(u.VpnKey); priv != "" {
+			keys = Keys{Private: priv, Public: u.PubKey, PSK: u.PskKey}
+		} else {
+			// Блоб не разобрался — личность пира восстановить неоткуда, выдаём новую.
+			s.log.Warn("reissue: vpn_key не декодируется, генерируем новую пару", "name", u.Name)
+			keys, err = s.generateKeys()
+			if err != nil {
+				return nil, err
+			}
+			runCmd("awg", "set", s.iface, "peer", u.PubKey, "remove")
+			if r := s.setPeer(keys.Public, keys.PSK, u.IP); !r.ok() {
+				s.log.Error("reissue: awg set failed", "name", u.Name, "stderr", r.Stderr)
+				continue
+			}
+			res.Regenerated = append(res.Regenerated, u.Name)
+		}
+		vk, err := EncodeVpnKey(s.keyEnv(), keys, u.IP, serverPub)
+		if err != nil {
+			return nil, err
+		}
+		if _, err := s.db.Exec("UPDATE users SET vpn_key_prev = vpn_key, vpn_key = ?, pub_key = ?, psk_key = ?, key_gen = ? WHERE name = ?",
+			vk, keys.Public, keys.PSK, cfg.Gen, u.Name); err != nil {
+			return nil, err
+		}
+		res.Reissued++
+	}
+	if err := s.syncPeers(); err != nil {
+		return nil, err
+	}
+	s.log.Info("reissue: done", "total", len(users), "reissued", res.Reissued, "regenerated", len(res.Regenerated))
+	return res, nil
+}
+
+// ───────── пиры устройств (sen://) ─────────
+// awg-ctrl про мастер-ключи ничего не знает: ему приходит «добавь пира с этим публичным
+// ключом». Приватного ключа устройства здесь нет и быть не может.
+
+var rePub = regexp.MustCompile(`^[A-Za-z0-9+/]{43}=$`)
+
+// checkPubKey: base64 от 32 байт (44 символа, последний «=»).
+func checkPubKey(k string) (string, error) {
+	if !rePub.MatchString(k) {
+		return "", httpErr(400, "Неверный публичный ключ")
+	}
+	b, err := b64Std(k)
+	if err != nil || len(b) != 32 {
+		return "", httpErr(400, "Неверный публичный ключ")
+	}
+	return k, nil
+}
+
+// pubKeyFromParam: в пути base64url — «/» и «+» обычного base64 ломают маршрут.
+func pubKeyFromParam(p string) (string, error) {
+	b, err := lenientB64URL(p)
+	if err != nil {
+		return "", httpErr(400, "Неверный публичный ключ")
+	}
+	return checkPubKey(stdB64(b))
+}
+
+type ipPsk struct {
+	IP  string `json:"ip"`
+	PSK string `json:"psk_key"`
+}
+
+func (s *Server) assertPubKeyFree(q queryer, pub string) error {
+	var n int
+	if err := q.QueryRow("SELECT COUNT(*) FROM peers WHERE pub_key = ?", pub).Scan(&n); err != nil {
+		return err
+	}
+	taken, err := s.userPubTaken(q, pub)
+	if err != nil {
+		return err
+	}
+	if n > 0 || taken {
+		return httpErr(409, "Публичный ключ уже используется")
+	}
+	if sp, err := s.getServerPublicKey(); err != nil {
+		return err
+	} else if pub == sp {
+		return httpErr(409, "Публичный ключ уже используется")
+	}
+	return nil
+}
+
+func (s *Server) addPeer(pub, owner string) (*ipPsk, error) {
+	if _, err := checkPubKey(pub); err != nil {
+		return nil, err
+	}
+	psk, err := s.genPSK()
+	if err != nil {
+		return nil, err
+	}
+	tx, err := s.db.Begin()
+	if err != nil {
+		return nil, err
+	}
+	var ip string
+	err = s.assertPubKeyFree(tx, pub)
+	if err == nil {
+		ip, err = s.nextIp(tx, s.cfg().Subnet)
+	}
+	if err == nil {
+		_, err = tx.Exec("INSERT INTO peers (pub_key, ip, psk_key, owner, created_at) VALUES (?, ?, ?, ?, ?)",
+			pub, ip, psk, owner, time.Now().Unix())
+	}
+	if err != nil {
+		tx.Rollback()
+		return nil, err
+	}
+	if err := tx.Commit(); err != nil {
+		return nil, err
+	}
+	if r := s.setPeer(pub, psk, ip); !r.ok() {
+		s.db.Exec("DELETE FROM peers WHERE pub_key = ?", pub)
+		return nil, fmt.Errorf("awg set failed: %s", r.Stderr)
+	}
+	if err := s.rebuildConf(); err != nil {
+		return nil, err
+	}
+	s.log.Info("peer added", "owner", owner, "ip", ip)
+	return &ipPsk{ip, psk}, nil
+}
+
+// replacePeer — смена ключа устройства: IP и PSK остаются, меняется только pub_key.
+func (s *Server) replacePeer(oldPub, newPub string) (*ipPsk, error) {
+	if _, err := checkPubKey(newPub); err != nil {
+		return nil, err
+	}
+	old, err := s.peerGet(oldPub)
+	if err != nil {
+		return nil, err
+	}
+	if old == nil {
+		return nil, httpErr(404, "Пир не найден")
+	}
+	tx, err := s.db.Begin()
+	if err != nil {
+		return nil, err
+	}
+	if err = s.assertPubKeyFree(tx, newPub); err == nil {
+		_, err = tx.Exec("UPDATE peers SET pub_key = ? WHERE pub_key = ?", newPub, oldPub)
+	}
+	if err != nil {
+		tx.Rollback()
+		return nil, err
+	}
+	if err := tx.Commit(); err != nil {
+		return nil, err
+	}
+	if r := s.setPeer(newPub, old.PskKey, old.IP); !r.ok() {
+		s.db.Exec("UPDATE peers SET pub_key = ? WHERE pub_key = ?", oldPub, newPub)
+		return nil, fmt.Errorf("awg set failed: %s", r.Stderr)
+	}
+	// Старый ключ не снялся — пир остаётся «призраком» в ядре до аудита панели; смену ключа
+	// не откатываем: новый уже стоит, а клиент к этому моменту получил бы ошибку.
+	if !s.dropFromKernel(oldPub) {
+		s.log.Error("peer rekey: старый ключ остался в ядре", "owner", old.Owner)
+	}
+	if err := s.rebuildConf(); err != nil {
+		return nil, err
+	}
+	s.log.Info("peer rekeyed", "owner", old.Owner, "ip", old.IP)
+	return &ipPsk{old.IP, old.PskKey}, nil
+}
+
+func (s *Server) rotatePeerPSK(pub string) (*ipPsk, error) {
+	p, err := s.peerGet(pub)
+	if err != nil {
+		return nil, err
+	}
+	if p == nil {
+		return nil, httpErr(404, "Пир не найден")
+	}
+	psk, err := s.genPSK()
+	if err != nil {
+		return nil, err
+	}
+	if r := s.setPeer(pub, psk, p.IP); !r.ok() {
+		return nil, fmt.Errorf("awg set failed: %s", r.Stderr)
+	}
+	if _, err := s.db.Exec("UPDATE peers SET psk_key = ? WHERE pub_key = ?", psk, pub); err != nil {
+		return nil, err
+	}
+	if err := s.rebuildConf(); err != nil {
+		return nil, err
+	}
+	s.log.Info("peer psk rotated", "owner", p.Owner)
+	return &ipPsk{p.IP, psk}, nil
+}
+
+func (s *Server) removePeer(pub string) error {
+	p, err := s.peerGet(pub)
+	if err != nil {
+		return err
+	}
+	if p == nil {
+		return httpErr(404, "Пир не найден")
+	}
+	if !s.dropFromKernel(pub) {
+		return errors.New("Не удалось снять пира с интерфейса")
+	}
+	if _, err := s.db.Exec("DELETE FROM peers WHERE pub_key = ?", pub); err != nil {
+		return err
+	}
+	if err := s.rebuildConf(); err != nil {
+		return err
+	}
+	s.log.Info("peer removed", "owner", p.Owner)
+	return nil
+}
+
+var (
+	rePanelID     = regexp.MustCompile(`^[a-z0-9]{8,16}$`)
+	reLegacyOwner = regexp.MustCompile(`^m\d+/d\d+$`)
+)
+
+const syncMax = 10_000
+
+type legacyPeer struct {
+	PubKey string `json:"pub_key"`
+	Owner  string `json:"owner"`
+	IP     string `json:"ip"`
+}
+type syncResult struct {
+	Present []string     `json:"present"`
+	Removed int          `json:"removed"`
+	Legacy  []legacyPeer `json:"legacy"`
+}
+
+// syncOwnedPeers: панель присылает полный список ключей, которые ей нужны на этом сервере,
+// — всё остальное из её области («<panel>/…») снимается. Удаляем только по такому явному
+// списку, никогда по времени или неактивности: панель не на связи — ничего не происходит.
+// Пиры без области (owner «m1/d2», выданы до областей) панель забирает себе, только если их
+// ключ есть в её списке; остальные не трогаем — чьи они, уже не разобрать.
+func (s *Server) syncOwnedPeers(panel string, keep []string) (*syncResult, error) {
+	want := map[string]bool{}
+	for _, k := range keep {
+		want[k] = true
+	}
+	prefix := panel + "/"
+	peers, err := s.peersAll()
+	if err != nil {
+		return nil, err
+	}
+	var removed []peerRow
+	claimed := 0
+	for _, p := range peers {
+		switch {
+		case strings.HasPrefix(p.Owner, prefix):
+			// Ядро первым: не снялся — строка остаётся, следующий sync попробует снова.
+			if !want[p.PubKey] && s.dropFromKernel(p.PubKey) {
+				if _, err := s.db.Exec("DELETE FROM peers WHERE pub_key = ?", p.PubKey); err != nil {
+					return nil, err
+				}
+				removed = append(removed, p)
+			}
+		case reLegacyOwner.MatchString(p.Owner) && want[p.PubKey]:
+			if _, err := s.db.Exec("UPDATE peers SET owner = ? WHERE pub_key = ?", prefix+p.Owner, p.PubKey); err != nil {
+				return nil, err
+			}
+			claimed++
+		}
+	}
+	if len(removed) > 0 || claimed > 0 {
+		if err := s.rebuildConf(); err != nil {
+			return nil, err
+		}
+	}
+	if len(removed) > 0 {
+		owners := make([]string, len(removed))
+		for i, p := range removed {
+			owners[i] = p.Owner
+		}
+		s.log.Info("peers synced out", "panel", panel, "removed", owners)
+	}
+	all, err := s.peersAll()
+	if err != nil {
+		return nil, err
+	}
+	res := &syncResult{Present: []string{}, Removed: len(removed), Legacy: []legacyPeer{}}
+	for _, p := range all {
+		if strings.HasPrefix(p.Owner, prefix) {
+			res.Present = append(res.Present, p.PubKey)
+		}
+		if reLegacyOwner.MatchString(p.Owner) {
+			res.Legacy = append(res.Legacy, legacyPeer{p.PubKey, p.Owner, p.IP})
+		}
+	}
+	return res, nil
+}
+
+// ───────── переход 2.0 → 3.1 ─────────
+
+// Header protection использует библиотечный chacha-API, которого нет до ядра 5.5 — там
+// модуль 3.x просто не соберётся (upstream issue #210).
+func kernelRelease() string {
+	r := runCmd("uname", "-r")
+	return strings.TrimSpace(r.Stdout)
+}
+
+func kernelSupportsHeaderProtection(release string) bool {
+	parts := strings.Split(release, ".")
+	if len(parts) < 2 {
+		return false
+	}
+	maj, e1 := strconv.Atoi(leadingDigits(parts[0]))
+	min, e2 := strconv.Atoi(leadingDigits(parts[1]))
+	if e1 != nil || e2 != nil {
+		return false
+	}
+	return maj > 5 || (maj == 5 && min >= 5)
+}
+
+func leadingDigits(s string) string {
+	i := 0
+	for i < len(s) && s[i] >= '0' && s[i] <= '9' {
+		i++
+	}
+	return s[:i]
+}
+
+// checkGen31Support решает ЗАГРУЖЕННЫЙ модуль, а не тот, что лежит на диске после apt.
+func (s *Server) checkGen31Support() string {
+	module, _ := readVersions()
+	if !strings.HasPrefix(module, "3.") {
+		m := module
+		if m == "" {
+			m = "неизвестной версии"
+		}
+		return fmt.Sprintf("В ядре загружен модуль amneziawg %s — для 3.1 нужна 3.x. ", m) +
+			"Обнови пакет (apt) и перезагрузи сервер, затем повтори переход."
+	}
+	if rel := kernelRelease(); !kernelSupportsHeaderProtection(rel) {
+		return fmt.Sprintf("Ядро %s старше 5.5 — header protection в нём не работает (upstream issue #210).", rel)
+	}
+	return ""
+}
+
+var reAwg3KeyLine = regexp.MustCompile(`^\s*(` + strings.Join(AWG3Keys, "|") + `)\s*=`)
+
+// confWithGen31 готовит текст awg1.conf для 3.1: выкидывает старые 3.x-строки (конфиг могли
+// править руками), поднимает S1–S4 до допустимых при header protection и дописывает 3.x-блок
+// в конец [Interface]. [Peer]-блоки не трогаются — личности пиров переход не меняет.
+func confWithGen31(conf, headerKey string) (string, []string) {
+	var head, rest string
+	if loc := pPeerSplit.FindStringIndex(conf); loc != nil {
+		head, rest = conf[:loc[0]], conf[loc[0]:]
+	} else {
+		head = conf
+	}
+	var lines []string
+	for _, l := range strings.Split(head, "\n") {
+		if !reAwg3KeyLine.MatchString(l) {
+			lines = append(lines, l)
+		}
+	}
+	// Пустые строки и «# имя» в хвосте [Interface] относятся уже к первому [Peer] (их пишет
+	// rebuildConf) — отделяем, чтобы 3.x-строки встали внутрь [Interface].
+	var tail []string
+	for len(lines) > 0 {
+		t := strings.TrimSpace(lines[len(lines)-1])
+		if t != "" && !strings.HasPrefix(t, "#") {
+			break
+		}
+		tail = append([]string{lines[len(lines)-1]}, tail...)
+		lines = lines[:len(lines)-1]
+	}
+	if tt := strings.TrimSpace(strings.Join(tail, "\n")); tt != "" {
+		rest = tt + "\n" + rest
+	}
+	iface := strings.Join(lines, "\n")
+
+	// S ниже 12 (или вовсе отсутствующий) ядро с header protection не примет. Правка безопасна
+	// ровно потому, что следом идёт перевыпуск ключей: обе стороны получают новые значения
+	// одновременно. (Регулярка с \s*, как в Node-версии: захватывает и переводы строк.)
+	def := DefaultParams()
+	defaults := map[string]int{"S1": def.S1, "S2": def.S2, "S3": def.S3, "S4": def.S4}
+	bumped := []string{}
+	for _, k := range []string{"S1", "S2", "S3", "S4"} {
+		re := regexp.MustCompile(`(?m)^\s*` + k + `\s*=\s*(\d+)\s*$`)
+		m := re.FindStringSubmatch(iface)
+		cur := -1
+		if m != nil {
+			cur, _ = strconv.Atoi(m[1])
+		}
+		if m != nil && cur >= minSForHeaderProtection {
+			continue
+		}
+		val := defaults[k]
+		if minSForHeaderProtection > val {
+			val = minSForHeaderProtection
+		}
+		if m != nil {
+			// как iface.replace(re, …) без флага g: заменяется только первое совпадение
+			loc := re.FindStringIndex(iface)
+			iface = iface[:loc[0]] + fmt.Sprintf("%s = %d", k, val) + iface[loc[1]:]
+		} else {
+			iface = trimEndJS(iface) + fmt.Sprintf("\n%s = %d", k, val)
+		}
+		was := "нет"
+		if m != nil {
+			was = strconv.Itoa(cur)
+		}
+		bumped = append(bumped, fmt.Sprintf("%s: %s → %d", k, was, val))
+	}
+
+	a3 := []string{"HeaderProtectionKey = " + headerKey}
+	for _, kv := range AWG31Defaults {
+		a3 = append(a3, kv[0]+" = "+kv[1])
+	}
+	out := trimEndJS(iface) + "\n" + strings.Join(a3, "\n") + "\n"
+	if rest != "" {
+		out += "\n" + rest
+	}
+	return out, bumped
+}
+
+type upgradeResult struct {
+	Gen     string         `json:"gen"`
+	Backup  string         `json:"backup"`
+	BumpedS []string       `json:"bumpedS"`
+	Reissue *reissueResult `json:"reissue"`
+}
+
+// upgradeToGen31: единственная настоящая проверка, что ядро приняло параметры, — подъём
+// интерфейса, поэтому шаги такие: бэкап конфига → запись 3.1 → restartAwg() → перевыпуск
+// ключей. Если ядро отказало, возвращаем прежний конфиг и поднимаем интерфейс обратно:
+// операция либо применяется целиком, либо не оставляет следов.
+func (s *Server) upgradeToGen31() (*upgradeResult, error) {
+	before, err := os.ReadFile(s.confPath())
+	if err != nil {
+		return nil, err
+	}
+	backup := s.confPath() + ".bak-" + jsonStamp(time.Now())
+	if err := os.WriteFile(backup, before, 0o600); err != nil {
+		return nil, err
+	}
+	hk, err := s.genPSK()
+	if err != nil {
+		return nil, err
+	}
+	conf, bumped := confWithGen31(string(before), hk)
+	if err := os.WriteFile(s.confPath(), []byte(conf), 0o600); err != nil {
+		return nil, err
+	}
+	s.log.Info("upgrade: conf rewritten for 3.1", "backup", backup, "bumpedS", bumped)
+
+	rerr := s.restartAwg()
+	if rerr == nil && s.cfg().Gen != "3.1" {
+		rerr = errors.New("интерфейс поднялся, но конфиг всё ещё 2.0")
+	}
+	if rerr != nil {
+		s.log.Error("upgrade: kernel rejected 3.1, rolling back", "error", rerr)
+		os.WriteFile(s.confPath(), before, 0o600)
+		if e2 := s.restartAwg(); e2 != nil {
+			s.log.Error("upgrade: rollback restart failed", "error", e2)
+		}
+		return nil, fmt.Errorf("Ядро не приняло конфиг 3.1 — вернули прежний (копия: %s). "+
+			"Причина видна в dmesg после `echo \"module amneziawg +p\" > /sys/kernel/debug/dynamic_debug/control`.", backup)
+	}
+
+	// Ключи, выданные на 2.0-параметрах, после смены поколения не подключатся, поэтому
+	// перевыпускаем сразу — сервер не должен оставаться в состоянии «3.1 поднят, у всех
+	// нерабочие ключи». Личности пиров сохраняются.
+	re, err := s.reissueAll()
+	if err != nil {
+		return nil, err
+	}
+	s.log.Info("upgrade: done", "gen", s.cfg().Gen, "reissued", re.Reissued, "bumpedS", bumped)
+	return &upgradeResult{Gen: s.cfg().Gen, Backup: backup, BumpedS: bumped, Reissue: re}, nil
+}
+
+var _ = jsjson.Undefined

internal/ctrl/params.go

@@ -0,0 +1,152 @@
+package ctrl
+
+import (
+	"os"
+	"regexp"
+	"strconv"
+	"strings"
+)
+
+// AWG3Keys — ключи AmneziaWG 3.0/3.1. Порядок — порядок строк в клиентском .conf
+// (client/server_scripts/awg/template.conf в amnezia-client). Пустое значение =
+// ключ не задан: он не попадает ни в conf, ни в vpn://, и 2.0 остаётся побайтно прежним.
+var AWG3Keys = []string{
+	"HeaderProtectionKey",
+	"ContentPaddingAddition",
+	"RekeyAfterTime",
+	"RekeyTimeout",
+	"RejectAfterTime",
+	"KeepaliveTimeout",
+	"MaxHandshakeAttempts",
+	"RandomTrailers",
+	"DisableCookies",
+}
+
+// Params — параметры обфускации из [Interface] awg1.conf. Числовые — числа (в
+// vpn:// они уходят строками), остальные — строки.
+type Params struct {
+	Jc, Jmin, Jmax     int
+	S1, S2, S3, S4     int
+	H1, H2, H3, H4     string
+	I1, I2, I3, I4, I5 string
+	A3                 map[string]string // AWG3Keys → значение ("" = не задано)
+}
+
+// DefaultParams — запасные значения на случай, когда awg1.conf не найден.
+func DefaultParams() Params {
+	return Params{
+		Jc: 6, Jmin: 10, Jmax: 50,
+		S1: 90, S2: 45, S3: 37, S4: 14,
+		H1: "1224800044-2116730834",
+		H2: "2122053282-2133204808",
+		H3: "2133604274-2140756116",
+		H4: "2143656228-2147444225",
+		I1: "<r 2><b 0x858000010001000000000669636c6f756403636f6d0000010001c00c000100010000105a00044d583737>",
+		A3: map[string]string{},
+	}
+}
+
+func (p Params) a3(k string) string { return p.A3[k] }
+
+// Gen выводится из параметров, отдельного флага нет: conf — единственный источник
+// правды. Header protection — то, что ломает совместимость с 2.0.
+func (p Params) Gen() string {
+	if p.a3("HeaderProtectionKey") != "" {
+		return "3.1"
+	}
+	return "2"
+}
+
+var keepaliveByGen = map[string]string{"2": "25", "3.1": "25-35"}
+
+// AWG31Defaults — значения 3.1-параметров для перехода 2.0 → 3.1 (как у install.sh),
+// в порядке записи. HeaderProtectionKey генерируется на месте.
+var AWG31Defaults = [][2]string{
+	{"ContentPaddingAddition", "10-100"},
+	{"RekeyAfterTime", "100-120"},
+	{"RekeyTimeout", "3-7"},
+	{"RejectAfterTime", "150-180"},
+	{"KeepaliveTimeout", "5-15"},
+	{"MaxHandshakeAttempts", "15-20"},
+}
+
+// При заданном HeaderProtectionKey ни один из S1–S4 не может быть меньше 12.
+const minSForHeaderProtection = 12
+
+var (
+	pPeerSplit = regexp.MustCompile(`(?m)^\[Peer\]`)
+	numKeys    = []string{"Jc", "Jmin", "Jmax", "S1", "S2", "S3", "S4"}
+	strKeys    = append([]string{"H1", "H2", "H3", "H4", "I1", "I2", "I3", "I4", "I5"}, AWG3Keys...)
+)
+
+// ReadParams читает параметры из [Interface] awg1.conf (всё до первого [Peer]).
+//
+// Повторяет регулярки Node-версии: `^\s*K\s*=\s*(\d+)` с флагом m. `\s*` в JS
+// захватывает и перевод строки, так что строка «I2 = » без значения «съела» бы
+// следующую — install.sh таких не пишет, но поведение сохранено намеренно.
+func ReadParams(confFile string, warn func(string)) Params {
+	p := DefaultParams()
+	raw, err := os.ReadFile(confFile)
+	if err != nil {
+		if warn != nil {
+			warn("awg1.conf не найден — параметры обфускации по умолчанию")
+		}
+		return p
+	}
+	iface := pPeerSplit.Split(string(raw), 2)[0]
+
+	for _, k := range numKeys {
+		m := regexp.MustCompile(`(?m)^\s*` + k + `\s*=\s*(\d+)`).FindStringSubmatch(iface)
+		if m == nil {
+			continue
+		}
+		n, _ := strconv.Atoi(m[1])
+		switch k {
+		case "Jc":
+			p.Jc = n
+		case "Jmin":
+			p.Jmin = n
+		case "Jmax":
+			p.Jmax = n
+		case "S1":
+			p.S1 = n
+		case "S2":
+			p.S2 = n
+		case "S3":
+			p.S3 = n
+		case "S4":
+			p.S4 = n
+		}
+	}
+	for _, k := range strKeys {
+		// В JS `.` не совпадает с \n, \r, U+2028, U+2029; в Go-режиме (?m) без (?s) — только с \n.
+		m := regexp.MustCompile(`(?m)^\s*` + k + `\s*=\s*([^\n\r\x{2028}\x{2029}]*)$`).FindStringSubmatch(iface)
+		if m == nil {
+			continue
+		}
+		v := strings.TrimSpace(m[1])
+		switch k {
+		case "H1":
+			p.H1 = v
+		case "H2":
+			p.H2 = v
+		case "H3":
+			p.H3 = v
+		case "H4":
+			p.H4 = v
+		case "I1":
+			p.I1 = v
+		case "I2":
+			p.I2 = v
+		case "I3":
+			p.I3 = v
+		case "I4":
+			p.I4 = v
+		case "I5":
+			p.I5 = v
+		default:
+			p.A3[k] = v
+		}
+	}
+	return p
+}

internal/ctrl/routes.go

@@ -0,0 +1,410 @@
+package ctrl
+
+import (
+	"math"
+	"strconv"
+	"strings"
+	"time"
+
+	"github.com/maeneko/forgetting/internal/jsjson"
+)
+
+func nowFn() time.Time { return time.Now() }
+
+type ob = jsjson.Object
+type kv = jsjson.KV
+
+func ok(v any) (result, error)      { return result{200, v}, nil }
+func created(v any) (result, error) { return result{201, v}, nil }
+func (s *Server) routes() []route {
+	a := []func(*rctx) error{s.auth}
+	an := []func(*rctx) error{s.auth, validateName}
+	R := func(method, path string, lock bool, mw []func(*rctx) error, h func(*rctx) (result, error)) route {
+		segs := strings.Split(strings.Trim(path, "/"), "/")
+		return route{method: method, segs: segs, mw: mw, lock: lock, h: h}
+	}
+
+	return []route{
+		R("GET", "/health", false, nil, func(c *rctx) (result, error) {
+			st := s.interfaceStatus()
+			cfg := s.cfg()
+			status, word := 200, "ok"
+			awgSt := "ok"
+			if !st.Up {
+				status, word, awgSt = 503, "degraded", "down"
+			}
+			return result{status, ob{{"status", word}, {"server", cfg.ServerName}, {"ip", cfg.ServerIP}, {"gen", cfg.Gen},
+				{"awg", ob{{"status", awgSt}, {"peers", st.Peers}, {"module", cfg.AwgModule}, {"tools", cfg.AwgTools}}}}}, nil
+		}),
+
+		R("POST", "/api/users", true, an, func(c *rctx) (result, error) {
+			name, _ := c.obj().Get2("name").(string)
+			if u, err := s.userGet(name); err != nil {
+				return result{}, err
+			} else if u != nil {
+				return result{}, httpErr(409, "Пользователь уже существует")
+			}
+			u, err := s.addUser(name)
+			if err != nil {
+				return result{}, err
+			}
+			return created(u)
+		}),
+
+		R("GET", "/api/users", true, a, func(c *rctx) (result, error) {
+			rows, err := s.db.Query("SELECT name, ip, pub_key, vpn_key, key_gen FROM users WHERE vpn_key != ''")
+			if err != nil {
+				return result{}, err
+			}
+			stats := s.getPeersData()
+			list := []any{}
+			for rows.Next() {
+				var n, ip, pub, vk, kg string
+				if err := rows.Scan(&n, &ip, &pub, &vk, &kg); err != nil {
+					rows.Close()
+					return result{}, err
+				}
+				ps := stats[pub]
+				list = append(list, ob{{"name", n}, {"ip", ip}, {"pub_key", pub}, {"vpn_key", vk}, {"key_gen", kg},
+					{"online", ps.Online}, {"lastHandshake", ps.LastHandshake}})
+			}
+			rows.Close()
+			return ok(ob{{"users", list}})
+		}),
+
+		R("GET", "/api/users/stats", true, a, func(c *rctx) (result, error) {
+			torrent := s.torrent.SeenSet()
+			rows, err := s.db.Query("SELECT name, ip, pub_key, key_gen FROM users WHERE vpn_key != ''")
+			if err != nil {
+				return result{}, err
+			}
+			stats := s.getPeersData()
+			list := []any{}
+			for rows.Next() {
+				var n, ip, pub, kg string
+				if err := rows.Scan(&n, &ip, &pub, &kg); err != nil {
+					rows.Close()
+					return result{}, err
+				}
+				ps := stats[pub]
+				list = append(list, ob{{"name", n}, {"ip", ip}, {"key_gen", kg}, {"online", ps.Online},
+					{"lastHandshake", ps.LastHandshake}, {"rx", ps.Rx}, {"tx", ps.Tx}, {"priority", s.shaping.PriorityOf(ip)},
+					{"torrent", torrent[ip]}})
+			}
+			rows.Close()
+			return ok(ob{{"users", list}})
+		}),
+
+		// ⚠️ До «/api/users/:name», иначе тот примет «reissue» за имя пользователя.
+		R("POST", "/api/users/reissue", true, a, func(c *rctx) (result, error) {
+			r, err := s.reissueAll()
+			if err != nil {
+				return result{}, err
+			}
+			return ok(r)
+		}),
+
+		R("POST", "/api/users/:name", true, an, func(c *rctx) (result, error) {
+			u, err := s.userGet(c.params["name"])
+			if err != nil {
+				return result{}, err
+			}
+			if u == nil {
+				return result{}, httpErr(404, "Пользователь не найден")
+			}
+			return ok(u)
+		}),
+
+		R("DELETE", "/api/users/:name", true, an, func(c *rctx) (result, error) {
+			if err := s.removeUser(c.params["name"]); err != nil {
+				return result{}, err
+			}
+			return ok(ob{{"success", true}, {"name", c.params["name"]}})
+		}),
+
+		R("POST", "/api/peers", true, a, func(c *rctx) (result, error) {
+			owner, isStr := c.obj().Get2("owner").(string)
+			if !isStr || !reOwner.MatchString(owner) {
+				return result{}, httpErr(400, "Неверный owner")
+			}
+			pub, err := checkPubKeyAny(c.obj().Get2("pub_key"))
+			if err != nil {
+				return result{}, err
+			}
+			r, err := s.addPeer(pub, owner)
+			if err != nil {
+				return result{}, err
+			}
+			return created(r)
+		}),
+
+		R("GET", "/api/peers", true, a, func(c *rctx) (result, error) {
+			torrent := s.torrent.SeenSet()
+			stats := s.getPeersData()
+			peers, err := s.peersAll()
+			if err != nil {
+				return result{}, err
+			}
+			list := []any{}
+			for _, p := range peers {
+				ps := stats[p.PubKey]
+				list = append(list, ob{{"pub_key", p.PubKey}, {"ip", p.IP}, {"psk_key", p.PskKey}, {"owner", p.Owner},
+					{"online", ps.Online}, {"lastHandshake", ps.LastHandshake}, {"rx", ps.Rx}, {"tx", ps.Tx},
+					{"priority", s.shaping.PriorityOf(p.IP)}, {"torrent", torrent[p.IP]}})
+			}
+			return ok(ob{{"peers", list}})
+		}),
+
+		// Пиры, которые стоят в ядре, но неизвестны awg-ctrl (нет ни в users, ни в peers): снять
+		// их после сбоя `awg set … remove` некому. Только чтение — панель сама решает, что делать.
+		R("GET", "/api/audit", true, a, func(c *rctx) (result, error) {
+			r := runCmd("awg", "show", s.iface, "dump")
+			if !r.ok() {
+				return result{}, httpErr(503, "awg show не ответил")
+			}
+			known, err := s.knownPubKeys()
+			if err != nil {
+				return result{}, err
+			}
+			now := float64(time.Now().Unix())
+			ghosts := []any{}
+			lines := strings.Split(r.Stdout, "\n")
+			for _, l := range lines[1:] {
+				f := strings.Split(l, "\t")
+				if f[0] == "" || known[f[0]] {
+					continue
+				}
+				num := func(i int) float64 {
+					if i < len(f) {
+						return orZero(jsNumber(f[i]))
+					}
+					return 0
+				}
+				hs := num(4)
+				ghosts = append(ghosts, ob{{"pub_key", f[0]}, {"lastHandshake", hs}, {"online", hs > 0 && now-hs < 180}, {"rx", num(5)}, {"tx", num(6)}})
+			}
+			return ok(ob{{"ghosts", ghosts}})
+		}),
+
+		// Снять «призраков» из ядра. Ключи присылает панель, но здесь каждый перепроверяется:
+		// пир, который успел появиться в users/peers, не трогаем. Строк в базе у «призраков»
+		// нет — снимается только ядро.
+		R("POST", "/api/audit/clean", true, a, func(c *rctx) (result, error) {
+			arr, isArr := c.obj().Get2("pub_keys").([]any)
+			if !isArr || len(arr) > syncMax {
+				return result{}, httpErr(400, "Неверный список ключей")
+			}
+			keys, err := checkPubKeys(arr)
+			if err != nil {
+				return result{}, err
+			}
+			removed, skipped := []string{}, []string{}
+			for _, k := range keys {
+				known, err := s.isKnownPub(k)
+				if err != nil {
+					return result{}, err
+				}
+				skip := known
+				if !skip {
+					sp, err := s.getServerPublicKey()
+					if err != nil {
+						return result{}, err
+					}
+					kp := s.kernelPeers()
+					skip = k == sp || kp == nil || !kp[k]
+				}
+				if skip {
+					skipped = append(skipped, k)
+				} else if s.dropFromKernel(k) {
+					removed = append(removed, k)
+				} else {
+					skipped = append(skipped, k)
+				}
+			}
+			if len(removed) > 0 {
+				s.log.Warn("ghost peers removed from kernel", "count", len(removed), "removed", removed)
+			}
+			return ok(ob{{"removed", removed}, {"skipped", skipped}})
+		}),
+
+		// Должен стоять ДО PUT /api/peers/:pub — иначе тот примет «sync» за ключ.
+		R("PUT", "/api/peers/sync", true, a, func(c *rctx) (result, error) {
+			owner, isStr := c.obj().Get2("owner").(string)
+			if !isStr || !rePanelID.MatchString(owner) {
+				return result{}, httpErr(400, "Неверный owner")
+			}
+			arr, isArr := c.obj().Get2("keep").([]any)
+			if !isArr || len(arr) > syncMax {
+				return result{}, httpErr(400, "Неверный список ключей")
+			}
+			keep, err := checkPubKeys(arr)
+			if err != nil {
+				return result{}, err
+			}
+			r, err := s.syncOwnedPeers(owner, keep)
+			if err != nil {
+				return result{}, err
+			}
+			return ok(r)
+		}),
+
+		R("PUT", "/api/peers/:pub", true, a, func(c *rctx) (result, error) {
+			oldPub, err := pubKeyFromParam(c.params["pub"])
+			if err != nil {
+				return result{}, err
+			}
+			newPub, err := checkPubKeyAny(c.obj().Get2("pub_key"))
+			if err != nil {
+				return result{}, err
+			}
+			r, err := s.replacePeer(oldPub, newPub)
+			if err != nil {
+				return result{}, err
+			}
+			return ok(r)
+		}),
+
+		R("POST", "/api/peers/:pub/psk", true, a, func(c *rctx) (result, error) {
+			pub, err := pubKeyFromParam(c.params["pub"])
+			if err != nil {
+				return result{}, err
+			}
+			r, err := s.rotatePeerPSK(pub)
+			if err != nil {
+				return result{}, err
+			}
+			return ok(r)
+		}),
+
+		R("DELETE", "/api/peers/:pub", true, a, func(c *rctx) (result, error) {
+			pub, err := pubKeyFromParam(c.params["pub"])
+			if err != nil {
+				return result{}, err
+			}
+			if err := s.removePeer(pub); err != nil {
+				return result{}, err
+			}
+			return ok(ob{{"success", true}})
+		}),
+
+		// Общая часть клиентского конфига для подписки. Ключи obfuscation — именами .conf;
+		// пустые (I2–I5, весь 3.x-блок на 2.0) не выводятся, как и в самом conf.
+		R("GET", "/api/profile", true, a, func(c *rctx) (result, error) {
+			sp, err := s.getServerPublicKey()
+			if err != nil {
+				return result{}, err
+			}
+			cfg := s.cfg()
+			return ok(ob{{"name", cfg.ServerName}, {"endpoint", cfg.ServerIP + ":" + strconv.Itoa(cfg.ServerPort)},
+				{"server_pub", sp}, {"gen", cfg.Gen}, {"dns", []string{cfg.DNS1, cfg.DNS2}},
+				{"keepalive", cfg.Keepalive}, {"mtu", cfg.MTU}, {"awg", profileAwg(cfg.Params)}})
+		}),
+
+		R("POST", "/awg/restart", true, a, func(c *rctx) (result, error) {
+			if err := s.restartAwg(); err != nil {
+				return result{}, err
+			}
+			return ok(ob{{"success", true}})
+		}),
+
+		// Перевод сервера с 2.0 на 3.1 — включая перевыпуск всех vpn:// ключей. Ошибку отдаём
+		// текстом: панель показывает её оператору, а причины отказа (старый модуль, старое ядро,
+		// отказ ядра на подъёме) требуют разных действий.
+		R("POST", "/awg/upgrade", true, a, func(c *rctx) (result, error) {
+			if s.cfg().Gen == "3.1" {
+				return result{}, httpErr(409, "Сервер уже работает на AmneziaWG 3.1")
+			}
+			if blocker := s.checkGen31Support(); blocker != "" {
+				return result{}, httpErr(409, blocker)
+			}
+			r, err := s.upgradeToGen31()
+			if err != nil {
+				return result{}, httpErr(500, err.Error())
+			}
+			return ok(r)
+		}),
+
+		// Деление канала между устройствами. Путь под /api/ — иначе awg-agent на ноде его не
+		// пропустит (и без PATCH: агент отвечает на него 400).
+		R("GET", "/api/shaping", false, a, func(c *rctx) (result, error) { return ok(s.shaping.Status()) }),
+
+		R("PUT", "/api/shaping", false, a, func(c *rctx) (result, error) {
+			b := c.obj()
+			enabled, e1 := b.Get2("enabled").(bool)
+			auto, e2 := b.Get2("auto").(bool)
+			if !e1 || !e2 {
+				return result{}, httpErr(400, "enabled и auto должны быть true/false")
+			}
+			mbit := func(v any, what string) (int, error) {
+				n := jsToNumber(v)
+				if math.IsNaN(n) || n != math.Trunc(n) || n < 0 || n > 100_000 {
+					return 0, httpErr(400, what+": целое число Мбит/с от 1 до 100000")
+				}
+				return int(n), nil
+			}
+			down, err := mbit(b.Get2("downMbit"), "Загрузка")
+			if err != nil {
+				return result{}, err
+			}
+			up, err := mbit(b.Get2("upMbit"), "Отдача")
+			if err != nil {
+				return result{}, err
+			}
+			if enabled && (down < 1 || up < 1) {
+				return result{}, httpErr(400, "Для включения укажите ширину канала в обе стороны")
+			}
+			// tc/nft/модуль не нашлись или ядро отказало: оператору нужна причина, а не 500.
+			if err := s.shaping.Update(ShapingSettings{Enabled: enabled, DownMbit: down, UpMbit: up, Auto: auto}); err != nil {
+				return result{}, httpErr(500, err.Error())
+			}
+			return ok(s.shaping.Status())
+		}),
+
+		// Блокировка BitTorrent. Тоже под /api/ и через PUT — чтобы проходила через awg-agent на ноде.
+		R("GET", "/api/torrent", false, a, func(c *rctx) (result, error) { return ok(s.torrent.Status()) }),
+
+		R("PUT", "/api/torrent", false, a, func(c *rctx) (result, error) {
+			enabled, isBool := c.obj().Get2("enabled").(bool)
+			if !isBool {
+				return result{}, httpErr(400, "enabled должен быть true/false")
+			}
+			// nft не нашёлся или ядро отказало: оператору нужна причина, а не 500.
+			if err := s.torrent.Update(TorrentSettings{Enabled: enabled}); err != nil {
+				return result{}, httpErr(500, err.Error())
+			}
+			return ok(s.torrent.Status())
+		}),
+
+		R("GET", "/api/metrics", false, a, func(c *rctx) (result, error) {
+			d, err := s.metricsCached()
+			if err != nil {
+				return result{}, err
+			}
+			return ok(d)
+		}),
+
+		R("POST", "/api/monitor/install", false, a, func(c *rctx) (result, error) {
+			if err := s.startMonitorJob("install"); err != nil {
+				return result{}, err
+			}
+			return result{202, ob{{"running", true}, {"action", "install"}}}, nil
+		}),
+		R("POST", "/api/monitor/remove", false, a, func(c *rctx) (result, error) {
+			if err := s.startMonitorJob("remove"); err != nil {
+				return result{}, err
+			}
+			return result{202, ob{{"running", true}, {"action", "remove"}}}, nil
+		}),
+		R("GET", "/api/monitor/job", false, a, func(c *rctx) (result, error) { return ok(s.monitorView()) }),
+
+		R("GET", "/awg/status", true, a, func(c *rctx) (result, error) { return ok(s.interfaceStatus()) }),
+
+		R("POST", "/awg/start", true, a, func(c *rctx) (result, error) {
+			st, err := s.startInterface()
+			if err != nil {
+				return result{}, err
+			}
+			return ok(st)
+		}),
+	}
+}

internal/ctrl/server.go

@@ -0,0 +1,189 @@
+// Package ctrl — awg-ctrl: привилегированный REST API, который управляет интерфейсом
+// AmneziaWG (`awg`, `awg-quick`, `ip`, `tc`, `nft`) и базой пользователей users.db.
+// Слушает только 127.0.0.1; снаружи до него добирается лишь awg-ui (и агент ноды, и CLI)
+// с подписанным Ed25519-токеном.
+package ctrl
+
+import (
+	"crypto/ed25519"
+	"database/sql"
+	"fmt"
+	"net"
+	"net/http"
+	"os"
+	"path/filepath"
+	"regexp"
+	"strconv"
+	"sync"
+	"time"
+
+	"github.com/maeneko/forgetting/internal/iauth"
+	"github.com/maeneko/forgetting/internal/logx"
+)
+
+// Config — то, что в Node-версии лежало в CONFIG. Параметры и поколение меняются при
+// restartAwg/переходе на 3.1 — читать через Server.cfg().
+type Config struct {
+	ServerIP   string
+	ServerPort int
+	ServerName string
+	DNS1, DNS2 string
+	MTU        int
+	Keepalive  string
+	Subnet     string
+	Params     Params
+	Gen        string
+	AwgModule  string
+	AwgTools   string
+}
+
+type Server struct {
+	iface             string
+	confDir           string
+	dbPath            string
+	serverPrivKeyFile string
+	port              int
+
+	db  *sql.DB
+	log *logx.Logger
+	pub ed25519.PublicKey
+
+	// mu делает последовательности «БД + awg + awg1.conf» неделимыми. В Node весь код между
+	// await атомарен (один поток); в Go без этого два запроса перемешали бы шаги.
+	mu    sync.Mutex
+	cfgMu sync.RWMutex
+	c     Config
+
+	shaping *Shaping
+	torrent *Torrent
+	metrics metricsCache
+	monitor monitorJob
+	cliPath string
+	cliLog  string
+}
+
+func (s *Server) cfg() Config {
+	s.cfgMu.RLock()
+	defer s.cfgMu.RUnlock()
+	return s.c
+}
+
+func (s *Server) keyEnv() keyEnv {
+	c := s.cfg()
+	return keyEnv{P: c.Params, ServerIP: c.ServerIP, ServerPort: c.ServerPort, ServerName: c.ServerName,
+		DNS1: c.DNS1, DNS2: c.DNS2, MTU: c.MTU, Keepalive: c.Keepalive, Gen: c.Gen, Subnet: c.Subnet}
+}
+
+func envOr(key, def string) string {
+	if v, ok := os.LookupEnv(key); ok {
+		return v
+	}
+	return def
+}
+
+func getLocalIP() string {
+	r := runCmd("ip", "route", "show", "default")
+	m := regexp.MustCompile(`dev\s+(\S+)`).FindStringSubmatch(r.Stdout)
+	if m == nil {
+		return ""
+	}
+	a := runCmd("ip", "addr", "show", m[1])
+	if m := regexp.MustCompile(`inet\s+([\d.]+)`).FindStringSubmatch(a.Stdout); m != nil {
+		return m[1]
+	}
+	return ""
+}
+
+// New открывает базу и ключи, читает параметры из awg1.conf. Не слушает порт.
+func New() (*Server, error) {
+	s := &Server{
+		iface:             "awg1",
+		confDir:           envOr("AWG_CONF_DIR", "/etc/amnezia/amneziawg"),
+		serverPrivKeyFile: envOr("AWG_SERVER_PRIV_KEY_FILE", "/etc/amnezia/server_private.key"),
+		cliPath:           envOr("AWG_CLI", "/usr/local/bin/awg-ctrl"),
+	}
+	s.dbPath = envOr("AWG_DB_PATH", filepath.Join(s.confDir, "users.db"))
+	port, _ := strconv.Atoi(os.Getenv("PORT"))
+	if port == 0 {
+		port = 3005
+	}
+	s.port = port
+	cwd, _ := os.Getwd()
+	s.log = logx.New(os.Stdout, filepath.Join(cwd, "logs"))
+	s.cliLog = envOr("MONITOR_LOG", filepath.Join(filepath.Dir(cwd), "logs", "monitor-job.log"))
+
+	pubFile := envOr("INTERNAL_AUTH_PUB_FILE", "/etc/amnezia/amneziawg/internal_auth_public.key")
+	pub, err := iauth.LoadPublic(pubFile)
+	if err != nil {
+		s.log.Error("FATAL: публичный ключ внутренней авторизации не найден: " + pubFile)
+		return nil, fmt.Errorf("FATAL: публичный ключ внутренней авторизации не найден: %s", pubFile)
+	}
+	s.pub = pub
+
+	db, err := openDB(s.dbPath)
+	if err != nil {
+		return nil, err
+	}
+	s.db = db
+
+	// Адрес/порт/имя: БД, затем env, затем (для адреса) маршрут по умолчанию. Как в Node,
+	// запасной адрес вычисляется всегда, даже если в БД уже есть значение.
+	fallbackIP := ""
+	if v, ok := os.LookupEnv("SERVER_IP"); ok {
+		fallbackIP = v
+	} else {
+		fallbackIP = getLocalIP()
+	}
+	ip := s.getCfg("serverIp", fallbackIP)
+	portStr := s.getCfg("serverPort", envOr("SERVER_PORT", "51820"))
+	name := s.getCfg("serverName", envOr("SERVER_NAME", "VPN"))
+	if ip == "" {
+		return nil, fmt.Errorf("SERVER_IP не задан — передай через env при первом запуске")
+	}
+	s.setCfg("serverIp", ip)
+	s.setCfg("serverPort", portStr)
+	s.setCfg("serverName", name)
+	sp, _ := strconv.Atoi(portStr)
+
+	params := ReadParams(s.confPath(), func(m string) { s.log.Warn(m) })
+	gen := params.Gen()
+	module, tools := readVersions()
+	s.c = Config{
+		ServerIP: ip, ServerPort: sp, ServerName: name,
+		DNS1: "1.1.1.1", DNS2: "1.0.0.1", MTU: 1376, Subnet: "10.9",
+		Keepalive: keepaliveByGen[gen], Params: params, Gen: gen,
+		AwgModule: module, AwgTools: tools,
+	}
+	s.log.Info("awg params loaded from conf", "Jc", params.Jc, "H1", params.H1, "gen", gen)
+	s.shaping = newShaping(s)
+	s.torrent = newTorrent(s)
+	return s, nil
+}
+
+// Run слушает 127.0.0.1:PORT и выполняет стартовую последовательность Node-версии:
+// listen → ensureInterfaceUp → syncPeers → шейпинг. Нет интерфейса — завершаемся с ошибкой:
+// health-gate CLI опирается на это (без поднятого awg1 awg-ctrl не нужен).
+func (s *Server) Run() error {
+	ln, err := net.Listen("tcp", fmt.Sprintf("127.0.0.1:%d", s.port))
+	if err != nil {
+		return err
+	}
+	srv := &http.Server{Handler: s.handler(), ReadHeaderTimeout: 15 * time.Second}
+	errc := make(chan error, 1)
+	go func() { errc <- srv.Serve(ln) }()
+	c := s.cfg()
+	s.log.Info("Server started", "port", s.port, "host", "127.0.0.1", "serverName", c.ServerName, "serverIp", c.ServerIP)
+
+	if err := s.ensureInterfaceUp(); err != nil {
+		return err
+	}
+	if err := s.syncPeers(); err != nil {
+		return err
+	}
+	// Обязательно и на старте: при загрузке интерфейс поднимает systemd (ExecStartPre),
+	// ни один из путей awg-quick up внутри awg-ctrl тогда не срабатывает.
+	go s.shaping.Apply()
+	s.shaping.Start()
+	go s.torrent.Apply() // nft-таблицы после перезагрузки нет — ставим заново
+	return <-errc
+}

internal/ctrl/shaping.go

@@ -0,0 +1,634 @@
+package ctrl
+
+import (
+	"bytes"
+	"context"
+	"encoding/json"
+	"fmt"
+	"math"
+	"os"
+	"os/exec"
+	"strconv"
+	"strings"
+	"sync"
+	"time"
+)
+
+// Честное деление канала между устройствами (CAKE) + автоподстройка по RFC 6057.
+//
+// Схема:
+//   загрузка (к клиенту)   — CAKE root на awg1, dual-dsthost, diffserv3
+//   отдача (от клиента)    — ingress awg1 → ifb-awg, CAKE dual-srchost, besteffort
+//   тяжёлые при перегрузке — DSCP CS1 (bulk-tin CAKE) через отдельную nft-таблицу
+//   с меткой «торренты»   — туда же, пока метка висит (см. torrent.go), независимо от перегрузки
+//
+// Ничего не пишет в awg1.conf (PostUp не трогаем): всё применяется из процесса и
+// идемпотентно. Правила tc пропадают вместе с интерфейсом, поэтому Apply зовётся на
+// старте, после restartAwg()/startInterface() и из страховочной проверки в цикле.
+//
+// Сэмплер только КЛАССИФИЦИРУЕТ. Он никого не удаляет и не отключает — ни по времени,
+// ни по неактивности (правило проекта: удаление только по явному списку от панели).
+
+type ShapingSettings struct {
+	Enabled  bool `json:"enabled"`
+	DownMbit int  `json:"downMbit"`
+	UpMbit   int  `json:"upMbit"`
+	Auto     bool `json:"auto"`
+}
+
+type QdiscStats struct {
+	Packets float64 `json:"packets"`
+	Bytes   float64 `json:"bytes"`
+	Drops   float64 `json:"drops"`
+	Backlog float64 `json:"backlog"`
+}
+
+type ShapingStatus struct {
+	Settings  ShapingSettings `json:"settings"`
+	Active    bool            `json:"active"`
+	Congested bool            `json:"congested"`
+	Heavy     []string        `json:"heavy"`
+	Devices   int             `json:"devices"`
+	RateDown  float64         `json:"rateDown"`
+	RateUp    float64         `json:"rateUp"`
+	Down      *QdiscStats     `json:"down,omitempty"`
+	Up        *QdiscStats     `json:"up,omitempty"`
+}
+
+const (
+	congestOn    = 0.85 // доля ширины, выше которой канал считается перегруженным
+	congestOff   = 0.70 // и ниже которой перегрузка снимается (гистерезис)
+	activeMbit   = 0.1  // меньше — устройство не считается активным
+	heavyMult    = 1.5  // тяжёлое: ≥ 1.5 честных долей…
+	heavyMinFrac = 0.05 // …и не меньше 5% ширины канала
+	checkEvery   = 3    // страховочная проверка qdisc — раз в N тиков
+	ifbName      = "ifb-awg"
+	nftTable     = "awg_shape"
+)
+
+// Окна и пороги; переопределение через env — только для тестов на стенде.
+func envNum(key string, def float64) float64 {
+	if v := os.Getenv(key); v != "" {
+		if f, err := strconv.ParseFloat(v, 64); err == nil && f > 0 {
+			return f
+		}
+	}
+	return def
+}
+
+type tick struct{ dt, bytes float64 }
+
+type peerCounters struct {
+	IP     string
+	Rx, Tx float64
+}
+
+// orderedSet — множество с порядком вставки (JS Set): порядок попадает в nft-скрипт.
+type orderedSet struct {
+	keys []string
+	m    map[string]bool
+}
+
+func newOrderedSet() *orderedSet        { return &orderedSet{m: map[string]bool{}} }
+func (o *orderedSet) has(k string) bool { return o.m[k] }
+func (o *orderedSet) add(k string) {
+	if !o.m[k] {
+		o.m[k] = true
+		o.keys = append(o.keys, k)
+	}
+}
+func (o *orderedSet) del(k string) {
+	if !o.m[k] {
+		return
+	}
+	delete(o.m, k)
+	for i, x := range o.keys {
+		if x == k {
+			o.keys = append(o.keys[:i], o.keys[i+1:]...)
+			break
+		}
+	}
+}
+func (o *orderedSet) clear()         { o.keys, o.m = nil, map[string]bool{} }
+func (o *orderedSet) list() []string { return append([]string(nil), o.keys...) }
+func (o *orderedSet) size() int      { return len(o.keys) }
+
+type Shaping struct {
+	s *Server
+
+	opMu sync.Mutex // сериализует tc/nft: два параллельных Apply дали бы полусобранные qdisc
+
+	mu          sync.Mutex // состояние сэмплера
+	prev        map[string][2]float64
+	history     map[string][]tick
+	histOrder   []string
+	totals      []tick
+	heavy       *orderedSet
+	applied     *orderedSet // что сейчас стоит в nft-наборе: тяжёлые ∪ с меткой торрента
+	congested   bool
+	lastRateDn  float64
+	lastRateUp  float64
+	lastTickAt  time.Time
+	tickNo      int
+	lastError   string
+	windowTicks int
+	sampleS     float64
+	started     bool
+}
+
+func newShaping(s *Server) *Shaping {
+	sampleS := envNum("SHAPE_SAMPLE_S", 10)
+	windowS := envNum("SHAPE_WINDOW_S", 600)
+	return &Shaping{
+		s: s, prev: map[string][2]float64{}, history: map[string][]tick{}, heavy: newOrderedSet(), applied: newOrderedSet(),
+		sampleS: sampleS, windowTicks: int(math.Max(3, math.Round(windowS/sampleS))),
+	}
+}
+
+func (h *Shaping) Settings() ShapingSettings {
+	s := h.s
+	down, _ := strconv.Atoi(s.getCfg("shapeDownMbit", "0"))
+	up, _ := strconv.Atoi(s.getCfg("shapeUpMbit", "0"))
+	return ShapingSettings{
+		Enabled:  s.getCfg("shapeEnabled", "0") == "1",
+		DownMbit: down, UpMbit: up,
+		Auto: s.getCfg("shapeAuto", "1") == "1",
+	}
+}
+
+func (h *Shaping) save(st ShapingSettings) {
+	b := func(v bool) string {
+		if v {
+			return "1"
+		}
+		return "0"
+	}
+	h.s.setCfg("shapeEnabled", b(st.Enabled))
+	h.s.setCfg("shapeDownMbit", strconv.Itoa(st.DownMbit))
+	h.s.setCfg("shapeUpMbit", strconv.Itoa(st.UpMbit))
+	h.s.setCfg("shapeAuto", b(st.Auto))
+}
+
+func (h *Shaping) noteError(err error) {
+	h.mu.Lock()
+	defer h.mu.Unlock()
+	if m := err.Error(); m != h.lastError { // одинаковую ошибку в лог не спамим
+		h.s.log.Warn("shaping: " + m)
+		h.lastError = m
+	}
+}
+
+func (h *Shaping) overhead() int {
+	if v := os.Getenv("SHAPE_OVERHEAD"); v != "" {
+		if f, err := strconv.ParseFloat(v, 64); err == nil && f >= 0 {
+			return int(f)
+		}
+	}
+	return 60 + h.s.cfg().Params.S4
+}
+
+func shExec(name string, args ...string) (string, error) {
+	return runCtx(15*time.Second, name, args...)
+}
+
+func shExecStdin(name string, args []string, input string) error {
+	ctx, cancel := context.WithTimeout(context.Background(), 15*time.Second)
+	defer cancel()
+	cmd := exec.CommandContext(ctx, name, args...)
+	var se bytes.Buffer
+	cmd.Stderr = &se
+	cmd.Stdin = strings.NewReader(input)
+	if err := cmd.Run(); err != nil {
+		msg := strings.TrimSpace(se.String())
+		if msg == "" {
+			msg = err.Error()
+		}
+		return fmt.Errorf("%s: %s", name, msg)
+	}
+	return nil
+}
+
+func (h *Shaping) nftApply(heavy []string) error {
+	elements := ""
+	if len(heavy) > 0 {
+		elements = "\n        elements = { " + strings.Join(heavy, ", ") + " }"
+	}
+	// add+delete в одной транзакции: таблица пересоздаётся атомарно, без окна без правил.
+	script := "\nadd table inet " + nftTable + "\ndelete table inet " + nftTable + "\ntable inet " + nftTable + " {\n" +
+		"    set heavy {\n        type ipv4_addr" + elements + "\n    }\n" +
+		"    chain postrouting {\n        type filter hook postrouting priority -150; policy accept;\n" +
+		"        oifname \"" + h.s.iface + "\" ip daddr @heavy ip dscp set cs1\n    }\n}\n"
+	return shExecStdin("nft", []string{"-f", "-"}, script)
+}
+
+func (h *Shaping) hasCake(dev string) bool {
+	out, err := shExec("tc", "qdisc", "show", "dev", dev, "root")
+	return err == nil && strings.Contains(out, "cake")
+}
+
+func (h *Shaping) hasIngressRedirect() bool {
+	out, err := shExec("tc", "filter", "show", "dev", h.s.iface, "parent", "ffff:")
+	return err == nil && strings.Contains(out, "mirred")
+}
+
+func (h *Shaping) applyNow() error {
+	st := h.Settings()
+	if !st.Enabled || st.DownMbit <= 0 || st.UpMbit <= 0 {
+		h.removeNow()
+		return nil
+	}
+	iface := h.s.iface
+	oh := strconv.Itoa(h.overhead())
+
+	// Загрузка (к клиенту). replace = change, если qdisc уже стоит: скорость меняется на лету.
+	if _, err := shExec("tc", "qdisc", "replace", "dev", iface, "root", "cake",
+		"bandwidth", fmt.Sprintf("%dmbit", st.DownMbit), "diffserv3", "dual-dsthost", "overhead", oh); err != nil {
+		return err
+	}
+	// Отдача (от клиента): зеркалим входящий трафик awg1 на ifb и делим там.
+	if _, err := shExec("ip", "link", "show", ifbName); err != nil {
+		if _, err := shExec("ip", "link", "add", ifbName, "type", "ifb"); err != nil {
+			return err
+		}
+	}
+	if _, err := shExec("ip", "link", "set", ifbName, "up"); err != nil {
+		return err
+	}
+	if _, err := shExec("tc", "qdisc", "replace", "dev", ifbName, "root", "cake",
+		"bandwidth", fmt.Sprintf("%dmbit", st.UpMbit), "besteffort", "dual-srchost", "overhead", oh); err != nil {
+		return err
+	}
+	if !h.hasIngressRedirect() {
+		shExec("tc", "qdisc", "del", "dev", iface, "ingress") // ошибки игнорируем
+		if _, err := shExec("tc", "qdisc", "add", "dev", iface, "handle", "ffff:", "ingress"); err != nil {
+			return err
+		}
+		if _, err := shExec("tc", "filter", "add", "dev", iface, "parent", "ffff:", "protocol", "all", "prio", "1",
+			"matchall", "action", "mirred", "egress", "redirect", "dev", ifbName); err != nil {
+			return err
+		}
+	}
+	heavy := h.desired()
+	if err := h.nftApply(heavy); err != nil {
+		return err
+	}
+	h.mu.Lock()
+	h.applied = setOf(heavy)
+	h.lastError = ""
+	h.mu.Unlock()
+	h.s.log.Info("shaping applied", "down", st.DownMbit, "up", st.UpMbit, "overhead", oh, "heavy", len(heavy))
+	return nil
+}
+
+func (h *Shaping) removeNow() {
+	iface := h.s.iface
+	shExec("tc", "qdisc", "del", "dev", iface, "root")
+	shExec("tc", "qdisc", "del", "dev", iface, "ingress")
+	shExec("ip", "link", "del", ifbName)
+	shExec("nft", "delete", "table", "inet", nftTable)
+	h.mu.Lock()
+	h.heavy.clear()
+	h.applied.clear()
+	h.history, h.histOrder, h.prev = map[string][]tick{}, nil, map[string][2]float64{}
+	h.totals = nil
+	h.congested = false
+	h.mu.Unlock()
+}
+
+// Apply не бросает: отсутствие tc/nft/модуля не должно валить awg-ctrl (в отличие от
+// ensureInterfaceUp).
+func (h *Shaping) Apply() {
+	h.opMu.Lock()
+	err := h.applyNow()
+	h.opMu.Unlock()
+	if err != nil {
+		h.noteError(err)
+	}
+}
+
+// Update сохраняет настройки и применяет их; ошибку применения отдаёт вызывающему —
+// пользователю нужна честная причина, а не молчаливый warn.
+func (h *Shaping) Update(st ShapingSettings) error {
+	h.save(st)
+	h.opMu.Lock()
+	err := h.applyNow()
+	h.opMu.Unlock()
+	if err == nil {
+		h.mu.Lock()
+		h.lastError = ""
+		h.mu.Unlock()
+	}
+	return err
+}
+
+// desired — кого держать в фоновом классе: тяжёлые (порядок сэмплера) и, следом, устройства с
+// меткой «торренты». Метку ставит и снимает nft (таймаут), поэтому сверяемся каждый тик.
+func (h *Shaping) desired() []string {
+	h.mu.Lock()
+	out := setOf(h.heavy.list())
+	h.mu.Unlock()
+	for _, ip := range h.s.torrent.SeenList() {
+		out.add(ip)
+	}
+	return out.list()
+}
+
+func setOf(list []string) *orderedSet {
+	o := newOrderedSet()
+	for _, k := range list {
+		o.add(k)
+	}
+	return o
+}
+
+// syncNft — привести nft-набор к desired(); без изменений nft не трогаем.
+func (h *Shaping) syncNft() {
+	want := h.desired()
+	h.mu.Lock()
+	same := len(want) == h.applied.size()
+	for _, ip := range want {
+		same = same && h.applied.has(ip)
+	}
+	h.mu.Unlock()
+	if same {
+		return
+	}
+	h.opMu.Lock()
+	err := h.nftApply(want)
+	h.opMu.Unlock()
+	if err != nil {
+		h.noteError(err)
+		return
+	}
+	h.mu.Lock()
+	h.applied = setOf(want)
+	h.mu.Unlock()
+}
+
+// ───────── сэмплер (RFC 6057) ─────────
+
+func (h *Shaping) pushTick(arr []tick, t tick) []tick {
+	arr = append(arr, t)
+	for len(arr) > h.windowTicks {
+		arr = arr[1:]
+	}
+	return arr
+}
+
+func mbit(arr []tick) float64 {
+	var dt, by float64
+	for _, t := range arr {
+		dt += t.dt
+		by += t.bytes
+	}
+	if dt <= 0 {
+		return 0
+	}
+	return by * 8 / dt / 1e6
+}
+
+func (h *Shaping) readPeers() ([]peerCounters, error) {
+	out, err := runCtx(10*time.Second, "awg", "show", h.s.iface, "dump")
+	if err != nil {
+		return nil, err
+	}
+	var rows []peerCounters
+	lines := strings.Split(out, "\n")
+	if len(lines) > 0 {
+		lines = lines[1:]
+	}
+	for _, l := range lines {
+		f := strings.Split(l, "\t")
+		if len(f) < 4 || f[0] == "" || f[3] == "" {
+			continue
+		}
+		ip := strings.SplitN(strings.SplitN(f[3], ",", 2)[0], "/", 2)[0]
+		rx, tx := 0.0, 0.0
+		if len(f) > 5 {
+			rx = orZero(jsNumber(f[5]))
+		}
+		if len(f) > 6 {
+			tx = orZero(jsNumber(f[6]))
+		}
+		rows = append(rows, peerCounters{ip, rx, tx})
+	}
+	return rows, nil
+}
+
+func orZero(f float64) float64 {
+	if math.IsNaN(f) {
+		return 0
+	}
+	return f
+}
+
+func (h *Shaping) tick() {
+	st := h.Settings()
+	if !st.Enabled {
+		return
+	}
+	now := time.Now()
+	h.mu.Lock()
+	dt := h.sampleS
+	if !h.lastTickAt.IsZero() {
+		dt = now.Sub(h.lastTickAt).Seconds()
+	}
+	h.lastTickAt = now
+	h.tickNo++
+	tickNo := h.tickNo
+	h.mu.Unlock()
+	// В конце любого тика, в том числе пока окно не набралось: метка торрента не ждёт 10 минут.
+	defer h.syncNft()
+
+	// Страховка: интерфейс могли поднять руками (awg-quick down/up) — qdisc тогда исчез.
+	if tickNo%checkEvery == 0 && !h.hasCake(h.s.iface) {
+		h.s.log.Warn("shaping: qdisc на интерфейсе пропал, применяю заново")
+		h.Apply()
+	}
+
+	peers, err := h.readPeers()
+	if err != nil {
+		h.noteError(err)
+		return
+	}
+
+	h.mu.Lock()
+	var totalDown, totalUp float64
+	seen := map[string]bool{}
+	for _, p := range peers {
+		seen[p.IP] = true
+		before, had := h.prev[p.IP]
+		// Счётчики ядра сбрасываются при down/up интерфейса и замене ключа пира →
+		// отрицательная дельта = 0.
+		dTx, dRx := 0.0, 0.0
+		if had && p.Tx >= before[1] {
+			dTx = p.Tx - before[1]
+		}
+		if had && p.Rx >= before[0] {
+			dRx = p.Rx - before[0]
+		}
+		h.prev[p.IP] = [2]float64{p.Rx, p.Tx}
+		totalDown += dTx
+		totalUp += dRx
+		if _, ok := h.history[p.IP]; !ok {
+			h.histOrder = append(h.histOrder, p.IP)
+		}
+		h.history[p.IP] = h.pushTick(h.history[p.IP], tick{dt, dTx})
+	}
+	var kept []string
+	for _, ip := range h.histOrder {
+		if seen[ip] {
+			kept = append(kept, ip)
+			continue
+		}
+		delete(h.prev, ip)
+		delete(h.history, ip)
+		h.heavy.del(ip)
+	}
+	h.histOrder = kept
+	h.totals = h.pushTick(h.totals, tick{dt, totalDown})
+	h.lastRateDn = totalDown * 8 / dt / 1e6
+	h.lastRateUp = totalUp * 8 / dt / 1e6
+
+	if !st.Auto {
+		h.heavy.clear()
+		h.congested = false
+		h.mu.Unlock()
+		return
+	}
+	if len(h.totals) < h.windowTicks { // пока окно не набралось, решений не принимаем
+		h.mu.Unlock()
+		return
+	}
+
+	avg := mbit(h.totals)
+	wasCongested := h.congested
+	if !h.congested && avg >= congestOn*float64(st.DownMbit) {
+		h.congested = true
+	}
+	if h.congested && avg < congestOff*float64(st.DownMbit) {
+		h.congested = false
+	}
+
+	next := newOrderedSet()
+	if h.congested {
+		type rate struct {
+			ip string
+			r  float64
+		}
+		var rates []rate
+		for _, ip := range h.histOrder {
+			if hh := h.history[ip]; len(hh) >= h.windowTicks {
+				rates = append(rates, rate{ip, mbit(hh)})
+			}
+		}
+		active := 0
+		for _, r := range rates {
+			if r.r >= activeMbit {
+				active++
+			}
+		}
+		share := float64(st.DownMbit) / math.Max(1, float64(active))
+		for _, r := range rates {
+			wasHeavy := h.heavy.has(r.ip)
+			// Входим на 1.5 доли, выходим ниже 1.0 доли — без дребезга на границе.
+			if r.r >= math.Max(heavyMult*share, heavyMinFrac*float64(st.DownMbit)) || (wasHeavy && r.r >= share) {
+				next.add(r.ip)
+			}
+		}
+	}
+	changed := next.size() != h.heavy.size()
+	if !changed {
+		for _, ip := range next.keys {
+			if !h.heavy.has(ip) {
+				changed = true
+				break
+			}
+		}
+	}
+	if changed || wasCongested != h.congested {
+		h.heavy = next
+		h.s.log.Info("shaping: класс тяжёлых обновлён", "congested", h.congested, "avgMbit", math.Round(avg), "heavy", next.list())
+	}
+	h.mu.Unlock()
+}
+
+func (h *Shaping) Start() {
+	h.mu.Lock()
+	if h.started {
+		h.mu.Unlock()
+		return
+	}
+	h.started = true
+	h.mu.Unlock()
+	go func() {
+		t := time.NewTicker(time.Duration(h.sampleS * float64(time.Second)))
+		defer t.Stop()
+		var busy sync.Mutex
+		for range t.C {
+			if !busy.TryLock() { // предыдущий тик ещё идёт — пропускаем, а не копим очередь
+				continue
+			}
+			go func() {
+				defer busy.Unlock()
+				h.tick()
+			}()
+		}
+	}()
+}
+
+// ───────── состояние ─────────
+
+func (h *Shaping) qdiscStats(dev string) *QdiscStats {
+	out, err := shExec("tc", "-s", "-j", "qdisc", "show", "dev", dev, "root")
+	if err != nil {
+		return nil
+	}
+	var arr []map[string]any
+	if json.Unmarshal([]byte(out), &arr) != nil {
+		return nil
+	}
+	for _, q := range arr {
+		if q["kind"] == "cake" {
+			n := func(k string) float64 { f, _ := q[k].(float64); return f }
+			return &QdiscStats{n("packets"), n("bytes"), n("drops"), n("backlog")}
+		}
+	}
+	return nil
+}
+
+func (h *Shaping) PriorityOf(ip string) string {
+	h.mu.Lock()
+	defer h.mu.Unlock()
+	if h.applied.has(ip) { // то, что реально стоит в nft: тяжёлые и с меткой торрента
+		return "background"
+	}
+	return "normal"
+}
+
+func (h *Shaping) Status() ShapingStatus {
+	st := h.Settings()
+	var active bool
+	var down, up *QdiscStats
+	if st.Enabled {
+		active = h.hasCake(h.s.iface)
+		down, up = h.qdiscStats(h.s.iface), h.qdiscStats(ifbName)
+	}
+	h.mu.Lock()
+	defer h.mu.Unlock()
+	devices := 0
+	for _, hh := range h.history {
+		if mbit(hh) >= activeMbit {
+			devices++
+		}
+	}
+	heavy := h.applied.list()
+	if heavy == nil {
+		heavy = []string{}
+	}
+	round1 := func(f float64) float64 { return math.Round(f*10) / 10 }
+	return ShapingStatus{
+		Settings: st, Active: active, Congested: h.congested, Heavy: heavy, Devices: devices,
+		RateDown: round1(h.lastRateDn), RateUp: round1(h.lastRateUp), Down: down, Up: up,
+	}
+}

internal/ctrl/torrent.go

@@ -0,0 +1,310 @@
+package ctrl
+
+import (
+	"encoding/json"
+	"sort"
+	"strings"
+	"sync"
+	"time"
+)
+
+// Блокировка BitTorrent — то же, что sniffing + blackhole в Xray (3x-ui), только в ядре.
+//
+// Решение принимается по первым байтам и один раз на соединение: совпала сигнатура — соединение
+// получает бит в ct mark и дальше режется целиком, в обе стороны. Смотрим только то, что
+// клиенты шлют в интернет (iifname awg1), до NAT, поэтому источник — IP клиента в туннеле.
+//
+// Ловится: DHT (запросы и ответы), UDP-трекеры, начало uTP-соединения, а при поддержке @ih в
+// nft/ядре — ещё открытое TCP-рукопожатие и HTTP-анонс. Не ловится шифрованное рукопожатие
+// (MSE/PE) и HTTPS-трекеры — так же, как у Xray. Но без DHT и трекеров клиенту негде брать пиров.
+//
+// Как и шейпинг, ничего не пишет в awg1.conf: таблица ставится из процесса и идемпотентно.
+// nft-таблица не привязана к интерфейсу (iifname — по имени), поэтому переживает его рестарт;
+// после перезагрузки сервера её возвращает Apply на старте.
+
+type TorrentSettings struct {
+	Enabled bool `json:"enabled"`
+}
+
+type TorrentPeer struct {
+	IP   string `json:"ip"`
+	Name string `json:"name"` // имя пользователя; у sen://-устройства — пусто
+}
+
+type TorrentStatus struct {
+	Settings TorrentSettings `json:"settings"`
+	Active   bool            `json:"active"` // таблица реально стоит
+	TCP      bool            `json:"tcp"`    // проверяется и TCP (нужен @ih: nftables ≥ 1.0, свежее ядро)
+	Hits     float64         `json:"hits"`   // заблокированных попыток с последнего применения
+	Seen     []TorrentPeer   `json:"seen"`   // кто пытался за последние torrentSeenTTL
+	Error    string          `json:"error,omitempty"`
+}
+
+const (
+	torrentTable   = "awg_torrent"
+	torrentMark    = "0x00100000" // свой бит ct mark: чужие биты не трогаем
+	torrentSeenTTL = "10m"
+	torrentCacheS  = 5 * time.Second // /api/users/stats опрашивается часто — nft не дёргаем на каждый
+)
+
+// Сигнатуры. @th,64 — начало данных UDP (заголовок 8 байт); @ih,0 — начало данных TCP с учётом опций.
+const torrentUDPRules = `
+        udp dport 53 return
+        @th,64,96 0x64313a6164323a696432303a jump block
+        @th,64,96 0x64313a7264323a696432303a jump block
+        @th,64,96 0x000004172710198000000000 jump block
+        ct state new udp length >= 28 @th,64,8 0x41 @th,72,8 < 3 @th,128,32 0 jump block`
+
+// DHT-запрос «d1:ad2:id20:» и ответ «d1:rd2:id20:» (bencode, ключи отсортированы — «a»/«r» первые);
+// UDP-трекер: protocol_id 0x41727101980 + action connect (0); uTP SYN: тип 4, версия 1 (0x41),
+// расширение 0–2, timestamp_difference 0 — только в новом потоке, где QUIC начинается с длинного
+// заголовка (0xC0+), и не на 53-м порту, чтобы случайный ID DNS-запроса не сошёлся.
+
+const torrentTCPRules = `
+        @ih,0,128 0x13426974546f7272656e742070726f74 jump block
+        @ih,0,112 0x474554202f616e6e6f756e63653f jump block`
+
+// «\x13BitTorrent prot» — открытое рукопожатие пиров; «GET /announce?» — HTTP-трекер.
+
+type Torrent struct {
+	s *Server
+
+	opMu sync.Mutex // сериализует nft
+
+	mu      sync.Mutex
+	enabled bool // копия настройки в памяти: cached() зовут внутри циклов по строкам users, а
+	//                   соединение с SQLite одно — запрос в базу оттуда ждал бы его вечно
+	tcp       bool
+	lastError string
+	cacheAt   time.Time
+	cache     map[string]bool
+	cacheHits float64
+}
+
+func newTorrent(s *Server) *Torrent {
+	t := &Torrent{s: s}
+	t.enabled = t.Settings().Enabled
+	return t
+}
+
+func (t *Torrent) Settings() TorrentSettings {
+	return TorrentSettings{Enabled: t.s.getCfg("torrentBlock", "0") == "1"}
+}
+
+func (t *Torrent) script(tcp bool) string {
+	iface := t.s.iface
+	var b strings.Builder
+	// add+delete в одной транзакции: таблица пересоздаётся атомарно, без окна без правил.
+	b.WriteString("\nadd table inet " + torrentTable + "\ndelete table inet " + torrentTable + "\ntable inet " + torrentTable + " {\n")
+	b.WriteString("    counter hits {\n    }\n")
+	b.WriteString("    set seen {\n        type ipv4_addr\n        flags dynamic, timeout\n        timeout " + torrentSeenTTL + "\n    }\n")
+	b.WriteString("    chain block {\n        ct mark set ct mark or " + torrentMark + "\n        update @seen { ip saddr }\n        counter name \"hits\"\n        drop\n    }\n")
+	b.WriteString("    chain udp_sig {" + torrentUDPRules + "\n    }\n")
+	if tcp {
+		b.WriteString("    chain tcp_sig {" + torrentTCPRules + "\n    }\n")
+	}
+	b.WriteString("    chain forward {\n        type filter hook forward priority -10; policy accept;\n")
+	b.WriteString("        ct mark and " + torrentMark + " == " + torrentMark + " drop\n")
+	b.WriteString("        iifname \"" + iface + "\" meta nfproto ipv4 meta l4proto udp jump udp_sig\n")
+	if tcp {
+		b.WriteString("        iifname \"" + iface + "\" meta nfproto ipv4 meta l4proto tcp jump tcp_sig\n")
+	}
+	b.WriteString("    }\n}\n")
+	return b.String()
+}
+
+func (t *Torrent) applyNow() error {
+	if !t.Settings().Enabled {
+		t.removeNow()
+		return nil
+	}
+	// Сначала полный набор; старый nft/ядро не знают @ih — тогда без TCP, но UDP (DHT, трекеры,
+	// uTP) всё равно режем: это и есть основная часть.
+	tcp := true
+	err := shExecStdin("nft", []string{"-f", "-"}, t.script(true))
+	if err != nil {
+		tcp = false
+		if err2 := shExecStdin("nft", []string{"-f", "-"}, t.script(false)); err2 != nil {
+			return err2
+		}
+		t.s.log.Warn("torrent: TCP-сигнатуры не поддерживаются, блокируем только UDP", "nft", err.Error())
+	}
+	t.mu.Lock()
+	t.tcp, t.lastError, t.cache = tcp, "", nil
+	t.mu.Unlock()
+	t.s.log.Info("torrent block applied", "tcp", tcp)
+	return nil
+}
+
+func (t *Torrent) removeNow() {
+	shExec("nft", "delete", "table", "inet", torrentTable)
+	t.mu.Lock()
+	t.tcp, t.cache = false, nil
+	t.mu.Unlock()
+}
+
+func (t *Torrent) noteError(err error) {
+	t.mu.Lock()
+	defer t.mu.Unlock()
+	if m := err.Error(); m != t.lastError {
+		t.s.log.Warn("torrent: " + m)
+		t.lastError = m
+	}
+}
+
+// Apply не бросает: без nft awg-ctrl должен работать дальше (как шейпинг).
+func (t *Torrent) Apply() {
+	t.opMu.Lock()
+	err := t.applyNow()
+	t.opMu.Unlock()
+	if err != nil {
+		t.noteError(err)
+	}
+}
+
+// Update сохраняет и применяет; ошибку отдаёт вызывающему — оператору нужна причина.
+func (t *Torrent) Update(st TorrentSettings) error {
+	v := "0"
+	if st.Enabled {
+		v = "1"
+	}
+	t.s.setCfg("torrentBlock", v)
+	t.mu.Lock()
+	t.enabled, t.cache = st.Enabled, nil
+	t.mu.Unlock()
+	t.opMu.Lock()
+	err := t.applyNow()
+	t.opMu.Unlock()
+	if err != nil {
+		t.mu.Lock()
+		t.lastError = err.Error()
+		t.mu.Unlock()
+	}
+	return err
+}
+
+// read — набор seen и счётчик из ядра. ok=false — таблицы нет.
+func (t *Torrent) read() (seen map[string]bool, hits float64, ok bool) {
+	out, err := shExec("nft", "-j", "list", "set", "inet", torrentTable, "seen")
+	if err != nil {
+		return nil, 0, false
+	}
+	seen = map[string]bool{}
+	var doc struct {
+		Nftables []struct {
+			Set *struct {
+				Elem []json.RawMessage `json:"elem"`
+			} `json:"set"`
+			Counter *struct {
+				Packets float64 `json:"packets"`
+			} `json:"counter"`
+		} `json:"nftables"`
+	}
+	if json.Unmarshal([]byte(out), &doc) == nil {
+		for _, it := range doc.Nftables {
+			if it.Set == nil {
+				continue
+			}
+			// Элемент с таймаутом — {"elem": {"val": "10.9.0.2", ...}}, без него — просто строка.
+			for _, raw := range it.Set.Elem {
+				var ip string
+				if json.Unmarshal(raw, &ip) != nil {
+					var e struct {
+						Elem struct {
+							Val string `json:"val"`
+						} `json:"elem"`
+					}
+					if json.Unmarshal(raw, &e) == nil {
+						ip = e.Elem.Val
+					}
+				}
+				if ip != "" {
+					seen[ip] = true
+				}
+			}
+		}
+	}
+	if out, err := shExec("nft", "-j", "list", "counter", "inet", torrentTable, "hits"); err == nil {
+		doc.Nftables = nil
+		if json.Unmarshal([]byte(out), &doc) == nil {
+			for _, it := range doc.Nftables {
+				if it.Counter != nil {
+					hits = it.Counter.Packets
+				}
+			}
+		}
+	}
+	return seen, hits, true
+}
+
+// cached не трогает базу (только память и nft) — его можно звать где угодно.
+func (t *Torrent) cached() (map[string]bool, float64, bool) {
+	t.mu.Lock()
+	if !t.enabled {
+		t.mu.Unlock()
+		return nil, 0, false
+	}
+	if t.cache != nil && time.Since(t.cacheAt) < torrentCacheS {
+		c, h := t.cache, t.cacheHits
+		t.mu.Unlock()
+		return c, h, true
+	}
+	t.mu.Unlock()
+	seen, hits, ok := t.read()
+	if !ok {
+		return nil, 0, false
+	}
+	t.mu.Lock()
+	t.cache, t.cacheHits, t.cacheAt = seen, hits, time.Now()
+	t.mu.Unlock()
+	return seen, hits, true
+}
+
+// SeenSet — кто пытался открыть торрент-соединение за последние torrentSeenTTL. Берите его до
+// запроса к базе, а не внутри цикла по строкам: так на открытом курсоре не висит вызов nft.
+func (t *Torrent) SeenSet() map[string]bool {
+	seen, _, _ := t.cached()
+	out := make(map[string]bool, len(seen))
+	for ip := range seen {
+		out[ip] = true
+	}
+	return out
+}
+
+// SeenList — IP с меткой «торренты», по порядку; шейпинг держит их в фоновом классе.
+func (t *Torrent) SeenList() []string {
+	seen, _, _ := t.cached()
+	out := make([]string, 0, len(seen))
+	for ip := range seen {
+		out = append(out, ip)
+	}
+	sort.Strings(out)
+	return out
+}
+
+func (t *Torrent) Status() TorrentStatus {
+	st := TorrentStatus{Settings: t.Settings(), Seen: []TorrentPeer{}}
+	seen, hits, active := t.cached()
+	t.mu.Lock()
+	st.TCP, st.Error = t.tcp && active, t.lastError
+	t.mu.Unlock()
+	st.Active, st.Hits = active, hits
+	if len(seen) == 0 {
+		return st
+	}
+	names := map[string]string{}
+	if rows, err := t.s.db.Query("SELECT name, ip FROM users"); err == nil {
+		for rows.Next() {
+			var n, ip string
+			if rows.Scan(&n, &ip) == nil {
+				names[ip] = n
+			}
+		}
+		rows.Close()
+	}
+	for ip := range seen {
+		st.Seen = append(st.Seen, TorrentPeer{IP: ip, Name: names[ip]})
+	}
+	sort.Slice(st.Seen, func(i, j int) bool { return st.Seen[i].IP < st.Seen[j].IP })
+	return st
+}

internal/ctrl/vpnkey.go

@@ -0,0 +1,218 @@
+package ctrl
+
+import (
+	"bytes"
+	"compress/zlib"
+	"encoding/base64"
+	"encoding/binary"
+	"io"
+	"strconv"
+	"strings"
+
+	"github.com/maeneko/forgetting/internal/jsjson"
+)
+
+// Keys — пара ключей клиента и PSK.
+type Keys struct{ Private, Public, PSK string }
+
+// Подмножество CONFIG, нужное для сборки ключа.
+type keyEnv struct {
+	P          Params
+	ServerIP   string
+	ServerPort int
+	ServerName string
+	DNS1, DNS2 string
+	MTU        int
+	Keepalive  string
+	Gen        string
+	Subnet     string
+}
+
+// buildClientConf — клиентский .conf. Порядок: PrivateKey → AWG params (Jc,S,H,I) →
+// 3.x-ключи → Address → DNS.
+//
+// 🛑 Пустые I2–I5 выводятся как «I2 = » с ОДНИМ хвостовым пробелом (так в рабочих ключах
+// Amnezia). Пробел дан отдельной константой, чтобы его не срезала ни IDE, ни инструмент
+// правки. Не «чистить».
+func buildClientConf(e keyEnv, k Keys, ip, serverPub string) string {
+	const sp = " "
+	var awg3 strings.Builder
+	for _, key := range AWG3Keys {
+		if v := e.P.a3(key); v != "" {
+			awg3.WriteString(key + " = " + v + "\n")
+		}
+	}
+	var b strings.Builder
+	b.WriteString("[Interface]\n")
+	b.WriteString("PrivateKey = " + k.Private + "\n")
+	b.WriteString("Jc = " + strconv.Itoa(e.P.Jc) + "\n")
+	b.WriteString("Jmin = " + strconv.Itoa(e.P.Jmin) + "\n")
+	b.WriteString("Jmax = " + strconv.Itoa(e.P.Jmax) + "\n")
+	b.WriteString("S1 = " + strconv.Itoa(e.P.S1) + "\n")
+	b.WriteString("S2 = " + strconv.Itoa(e.P.S2) + "\n")
+	b.WriteString("S3 = " + strconv.Itoa(e.P.S3) + "\n")
+	b.WriteString("S4 = " + strconv.Itoa(e.P.S4) + "\n")
+	b.WriteString("H1 = " + e.P.H1 + "\n")
+	b.WriteString("H2 = " + e.P.H2 + "\n")
+	b.WriteString("H3 = " + e.P.H3 + "\n")
+	b.WriteString("H4 = " + e.P.H4 + "\n")
+	b.WriteString("I1 = " + e.P.I1 + "\n")
+	b.WriteString("I2 =" + sp + "\n")
+	b.WriteString("I3 =" + sp + "\n")
+	b.WriteString("I4 =" + sp + "\n")
+	b.WriteString("I5 =" + sp + "\n")
+	b.WriteString(awg3.String())
+	b.WriteString("Address = " + ip + "/32\n")
+	b.WriteString("DNS = " + e.DNS1 + ", " + e.DNS2 + "\n")
+	b.WriteString("\n[Peer]\n")
+	b.WriteString("PublicKey = " + serverPub + "\n")
+	b.WriteString("PresharedKey = " + k.PSK + "\n")
+	b.WriteString("AllowedIPs = 0.0.0.0/0, ::/0\n")
+	b.WriteString("Endpoint = " + e.ServerIP + ":" + strconv.Itoa(e.ServerPort) + "\n")
+	b.WriteString("PersistentKeepalive = " + e.Keepalive + "\n")
+	return b.String()
+}
+
+// awgObject собирает объект параметров в ASCII-алфавитном порядке, в каком его
+// сериализует QJsonObject клиента AmneziaVPN. Незаданные 3.x-ключи выбрасываются.
+func awgObject(p Params) jsjson.Object {
+	a := func(k string) any {
+		if p.a3(k) == "" {
+			return jsjson.Undefined
+		}
+		return p.a3(k)
+	}
+	return jsjson.Object{
+		{"ContentPaddingAddition", a("ContentPaddingAddition")},
+		{"DisableCookies", a("DisableCookies")},
+		{"H1", p.H1}, {"H2", p.H2}, {"H3", p.H3}, {"H4", p.H4},
+		{"HeaderProtectionKey", a("HeaderProtectionKey")},
+		{"I1", p.I1}, {"I2", ""}, {"I3", ""}, {"I4", ""}, {"I5", ""},
+		{"Jc", strconv.Itoa(p.Jc)},
+		{"Jmax", strconv.Itoa(p.Jmax)},
+		{"Jmin", strconv.Itoa(p.Jmin)},
+		{"KeepaliveTimeout", a("KeepaliveTimeout")},
+		{"MaxHandshakeAttempts", a("MaxHandshakeAttempts")},
+		{"RandomTrailers", a("RandomTrailers")},
+		{"RejectAfterTime", a("RejectAfterTime")},
+		{"RekeyAfterTime", a("RekeyAfterTime")},
+		{"RekeyTimeout", a("RekeyTimeout")},
+		{"S1", strconv.Itoa(p.S1)}, {"S2", strconv.Itoa(p.S2)},
+		{"S3", strconv.Itoa(p.S3)}, {"S4", strconv.Itoa(p.S4)},
+	}
+}
+
+// EncodeVpnKey собирает vpn://-ключ в формате AmneziaVPN: JSON → zlib → 4 байта длины
+// (BE, несжатой) → base64url без «=».
+//
+// Содержимое после распаковки совпадает с Node-версией байт в байт (порядок ключей,
+// типы: port — число внутри last_config и строка снаружи). Сам поток deflate у Go и
+// у C-zlib разный, поэтому строка vpn:// не совпадает побайтно — решение владельца
+// проекта: AmneziaVPN читает оба одинаково (qUncompress).
+func EncodeVpnKey(e keyEnv, k Keys, ip, serverPub string) (string, error) {
+	clientConf := buildClientConf(e, k, ip, serverPub)
+
+	lastConfig := append(awgObject(e.P),
+		jsjson.KV{"allowed_ips", []string{"0.0.0.0/0", "::/0"}},
+		jsjson.KV{"clientId", k.Public},
+		jsjson.KV{"client_ip", ip},
+		jsjson.KV{"client_priv_key", k.Private},
+		jsjson.KV{"client_pub_key", k.Public},
+		jsjson.KV{"config", clientConf},
+		jsjson.KV{"hostName", e.ServerIP},
+		jsjson.KV{"mtu", strconv.Itoa(e.MTU)},
+		jsjson.KV{"persistent_keep_alive", e.Keepalive},
+		jsjson.KV{"port", e.ServerPort},
+		jsjson.KV{"psk_key", k.PSK},
+		jsjson.KV{"server_pub_key", serverPub},
+	)
+	lastConfigJSON, err := jsjson.MarshalIndent(lastConfig, "  ")
+	if err != nil {
+		return "", err
+	}
+
+	awg := append(awgObject(e.P),
+		jsjson.KV{"last_config", string(lastConfigJSON)},
+		jsjson.KV{"port", strconv.Itoa(e.ServerPort)},
+		jsjson.KV{"protocol_version", e.Gen},
+		jsjson.KV{"subnet_address", e.Subnet + ".0.0"},
+		jsjson.KV{"transport_proto", "udp"},
+	)
+	outer := jsjson.Object{
+		{"containers", []any{jsjson.Object{{"container", "amnezia-awg2"}, {"awg", awg}}}},
+		{"defaultContainer", "amnezia-awg2"},
+		{"description", e.ServerName},
+		{"dns1", e.DNS1},
+		{"dns2", e.DNS2},
+		{"hostName", e.ServerIP},
+		{"nameOverriddenByUser", true},
+	}
+	js, err := jsjson.Marshal(outer)
+	if err != nil {
+		return "", err
+	}
+
+	var zb bytes.Buffer
+	zw, _ := zlib.NewWriterLevel(&zb, zlib.DefaultCompression)
+	if _, err := zw.Write(js); err != nil {
+		return "", err
+	}
+	if err := zw.Close(); err != nil {
+		return "", err
+	}
+	var hdr [4]byte
+	binary.BigEndian.PutUint32(hdr[:], uint32(len(js)))
+	return "vpn://" + base64.RawURLEncoding.EncodeToString(append(hdr[:], zb.Bytes()...)), nil
+}
+
+// DecodeVpnKey — обратная к EncodeVpnKey. Как Buffer.from(…, "base64url") в Node,
+// терпим паддинг, «+» и «/». Любая ошибка → nil.
+func DecodeVpnKey(key string) jsjson.Object {
+	s := strings.TrimPrefix(key, "vpn://")
+	s = strings.NewReplacer("+", "-", "/", "_").Replace(strings.TrimRight(s, "="))
+	buf, err := base64.RawURLEncoding.DecodeString(s)
+	if err != nil || len(buf) <= 4 {
+		return nil
+	}
+	zr, err := zlib.NewReader(bytes.NewReader(buf[4:]))
+	if err != nil {
+		return nil
+	}
+	defer zr.Close()
+	raw, err := io.ReadAll(zr)
+	if err != nil {
+		return nil
+	}
+	v, err := jsjson.Decode(raw)
+	if err != nil {
+		return nil
+	}
+	o, _ := v.(jsjson.Object)
+	return o
+}
+
+// clientPrivKeyFrom достаёт client_priv_key из last_config: приватный ключ клиента
+// нигде больше не хранится, и только так перевыпуск сохраняет личность пира.
+func clientPrivKeyFrom(vpnKey string) string {
+	o := DecodeVpnKey(vpnKey)
+	if o == nil {
+		return ""
+	}
+	containers, _ := o.Get2("containers").([]any)
+	if len(containers) == 0 {
+		return ""
+	}
+	c, _ := containers[0].(jsjson.Object)
+	awg, _ := c.Get2("awg").(jsjson.Object)
+	lc, ok := awg.Get2("last_config").(string)
+	if !ok {
+		return ""
+	}
+	v, err := jsjson.Decode([]byte(lc))
+	if err != nil {
+		return ""
+	}
+	obj, _ := v.(jsjson.Object)
+	priv, _ := obj.Get2("client_priv_key").(string)
+	return priv
+}

internal/iauth/iauth.go

@@ -0,0 +1,122 @@
+// Package iauth — внутренние токены между awg-ui / awg-agent / CLI и awg-ctrl.
+//
+// Формат — «JWT» с EdDSA: header {"alg":"EdDSA","typ":"JWT"}, payload {iss,iat,exp},
+// подпись Ed25519 над ASCII "h.p". Ключи — PEM от openssl: PKCS#8 (закрытый) и SPKI
+// (открытый). Проверка намеренно такая же нестрогая, как у Node-версии: только подпись
+// и exp (alg/iss/лишние сегменты не смотрим) — ужесточение отдельным шагом (zero trust).
+package iauth
+
+import (
+	"crypto/ed25519"
+	"crypto/x509"
+	"encoding/base64"
+	"encoding/pem"
+	"errors"
+	"os"
+	"strconv"
+	"strings"
+	"time"
+
+	"github.com/maeneko/forgetting/internal/jsjson"
+)
+
+func decodePEM(file string) ([]byte, error) {
+	raw, err := os.ReadFile(file)
+	if err != nil {
+		return nil, err
+	}
+	blk, _ := pem.Decode(raw)
+	if blk == nil {
+		return nil, errors.New("iauth: not a PEM file: " + file)
+	}
+	return blk.Bytes, nil
+}
+
+// LoadPublic читает открытый ключ (SPKI PEM).
+func LoadPublic(file string) (ed25519.PublicKey, error) {
+	der, err := decodePEM(file)
+	if err != nil {
+		return nil, err
+	}
+	k, err := x509.ParsePKIXPublicKey(der)
+	if err != nil {
+		return nil, err
+	}
+	pub, ok := k.(ed25519.PublicKey)
+	if !ok {
+		return nil, errors.New("iauth: not an Ed25519 public key")
+	}
+	return pub, nil
+}
+
+// LoadPrivate читает закрытый ключ (PKCS#8 PEM).
+func LoadPrivate(file string) (ed25519.PrivateKey, error) {
+	der, err := decodePEM(file)
+	if err != nil {
+		return nil, err
+	}
+	k, err := x509.ParsePKCS8PrivateKey(der)
+	if err != nil {
+		return nil, err
+	}
+	priv, ok := k.(ed25519.PrivateKey)
+	if !ok {
+		return nil, errors.New("iauth: not an Ed25519 private key")
+	}
+	return priv, nil
+}
+
+var b64 = base64.RawURLEncoding
+
+// Mint выпускает токен на 60 с.
+func Mint(priv ed25519.PrivateKey, iss string, now time.Time) string {
+	h := b64.EncodeToString([]byte(`{"alg":"EdDSA","typ":"JWT"}`))
+	t := now.Unix()
+	p := b64.EncodeToString(jsjson.MustMarshal(jsjson.Object{{Key: "iss", Val: iss}, {Key: "iat", Val: t}, {Key: "exp", Val: t + 60}}))
+	sig := ed25519.Sign(priv, []byte(h+"."+p))
+	return h + "." + p + "." + b64.EncodeToString(sig)
+}
+
+// lenient повторяет Buffer.from(s, "base64url") в Node: терпит паддинг, «+», «/».
+func lenient(s string) ([]byte, error) {
+	s = strings.NewReplacer("+", "-", "/", "_").Replace(strings.TrimRight(s, "="))
+	return b64.DecodeString(s)
+}
+
+// Verify — подпись верна и exp в будущем.
+func Verify(pub ed25519.PublicKey, token string, now time.Time) bool {
+	parts := strings.Split(token, ".")
+	if len(parts) < 3 || parts[0] == "" || parts[1] == "" || parts[2] == "" {
+		return false
+	}
+	sig, err := lenient(parts[2])
+	if err != nil || !ed25519.Verify(pub, []byte(parts[0]+"."+parts[1]), sig) {
+		return false
+	}
+	raw, err := lenient(parts[1])
+	if err != nil {
+		return false
+	}
+	v, err := jsjson.Decode(raw)
+	if err != nil {
+		return false
+	}
+	obj, ok := v.(jsjson.Object)
+	if !ok {
+		return false
+	}
+	var exp float64
+	switch e := obj.Get2("exp").(type) {
+	case float64:
+		exp = e
+	case string: // JS сравнил бы числовую строку как число
+		f, err := strconv.ParseFloat(strings.TrimSpace(e), 64)
+		if err != nil {
+			return false
+		}
+		exp = f
+	default:
+		return false
+	}
+	return exp > float64(now.Unix())
+}

internal/jsjson/decode.go

@@ -0,0 +1,86 @@
+package jsjson
+
+import (
+	"bytes"
+	"encoding/json"
+	"errors"
+	"io"
+)
+
+// Decode разбирает JSON с сохранением порядка ключей: объекты — Object, массивы —
+// []any, числа — float64, как JSON.parse. Нужен, чтобы JSON.stringify(JSON.parse(x))
+// воспроизводился точно (например, сохранённый профиль сервера с ключами awg).
+func Decode(data []byte) (any, error) {
+	d := json.NewDecoder(bytes.NewReader(data))
+	d.UseNumber()
+	v, err := decodeValue(d)
+	if err != nil {
+		return nil, err
+	}
+	if _, err := d.Token(); err != io.EOF {
+		return nil, errors.New("jsjson: trailing data")
+	}
+	return v, nil
+}
+
+func decodeValue(d *json.Decoder) (any, error) {
+	t, err := d.Token()
+	if err != nil {
+		return nil, err
+	}
+	switch x := t.(type) {
+	case json.Delim:
+		switch x {
+		case '{':
+			obj := Object{}
+			for d.More() {
+				kt, err := d.Token()
+				if err != nil {
+					return nil, err
+				}
+				key, ok := kt.(string)
+				if !ok {
+					return nil, errors.New("jsjson: object key is not a string")
+				}
+				val, err := decodeValue(d)
+				if err != nil {
+					return nil, err
+				}
+				// повторный ключ в JS перезаписывает значение, оставаясь на первом месте
+				replaced := false
+				for i := range obj {
+					if obj[i].Key == key {
+						obj[i].Val = val
+						replaced = true
+						break
+					}
+				}
+				if !replaced {
+					obj = append(obj, KV{key, val})
+				}
+			}
+			if _, err := d.Token(); err != nil {
+				return nil, err
+			}
+			return obj, nil
+		case '[':
+			arr := []any{}
+			for d.More() {
+				val, err := decodeValue(d)
+				if err != nil {
+					return nil, err
+				}
+				arr = append(arr, val)
+			}
+			if _, err := d.Token(); err != nil {
+				return nil, err
+			}
+			return arr, nil
+		}
+		return nil, errors.New("jsjson: unexpected delimiter")
+	case json.Number:
+		return x.Float64()
+	default:
+		return x, nil // string, bool, nil
+	}
+}

internal/jsjson/jsjson.go

@@ -0,0 +1,393 @@
+// Package jsjson повторяет JSON.stringify из JavaScript байт в байт.
+//
+// Зачем: выход Node-версии зашит в форматы, которые проверяют клиенты и хэши —
+// распакованное содержимое vpn://, rev конфига sen:// (sha256 от строки),
+// подписанные тела ответов /sub/v1, /api/profile. encoding/json отличается
+// (экранирует < > & и U+2028/2029, иначе пишет числа, добавляет перевод
+// строки, сортирует ключи map), поэтому здесь свой сериализатор.
+//
+// Порядок ключей — порядок объявления: Object хранит пары как есть, у структур
+// берутся поля по порядку (тег json задаёт имя, "-" — пропуск, omitempty —
+// пропуск нулевого значения, как undefined в JS).
+package jsjson
+
+import (
+	"bytes"
+	"encoding/json"
+	"fmt"
+	"math"
+	"reflect"
+	"strconv"
+	"strings"
+	"unicode/utf8"
+)
+
+// KV — пара ключ/значение упорядоченного объекта.
+type KV struct {
+	Key string
+	Val any
+}
+
+// Object — JS-объект с сохранённым порядком ключей.
+type Object []KV
+
+// Get возвращает значение по ключу.
+func (o Object) Get(key string) (any, bool) {
+	for _, kv := range o {
+		if kv.Key == key {
+			return kv.Val, true
+		}
+	}
+	return nil, false
+}
+
+// Raw — уже готовый JSON, вставляется как есть (без проверки).
+type Raw []byte
+
+// Marshal — аналог JSON.stringify(v).
+func Marshal(v any) ([]byte, error) {
+	var b bytes.Buffer
+	if err := encode(&b, reflect.ValueOf(v), "", ""); err != nil {
+		return nil, err
+	}
+	return b.Bytes(), nil
+}
+
+// MarshalIndent — аналог JSON.stringify(v, null, indent) (у нас indent = "  ").
+func MarshalIndent(v any, indent string) ([]byte, error) {
+	var b bytes.Buffer
+	if err := encode(&b, reflect.ValueOf(v), indent, ""); err != nil {
+		return nil, err
+	}
+	return b.Bytes(), nil
+}
+
+// MustMarshal — для значений, которые заведомо сериализуемы.
+func MustMarshal(v any) []byte {
+	b, err := Marshal(v)
+	if err != nil {
+		panic(err)
+	}
+	return b
+}
+
+var (
+	objectType = reflect.TypeOf(Object(nil))
+	rawType    = reflect.TypeOf(Raw(nil))
+	jsonRaw    = reflect.TypeOf(json.RawMessage(nil))
+	jsonNumber = reflect.TypeOf(json.Number(""))
+)
+
+func encode(b *bytes.Buffer, v reflect.Value, indent, cur string) error {
+	if !v.IsValid() {
+		b.WriteString("null")
+		return nil
+	}
+	switch v.Type() {
+	case objectType:
+		return encodeObject(b, v.Interface().(Object), indent, cur)
+	case rawType:
+		b.Write(v.Bytes())
+		return nil
+	case jsonRaw:
+		raw := v.Bytes()
+		if len(raw) == 0 {
+			b.WriteString("null")
+			return nil
+		}
+		// JSON.stringify(JSON.parse(x)): нормализуем, не доверяя форме исходника.
+		val, err := Decode(raw)
+		if err != nil {
+			return err
+		}
+		return encode(b, reflect.ValueOf(val), indent, cur)
+	case jsonNumber:
+		f, err := strconv.ParseFloat(v.String(), 64)
+		if err != nil {
+			return err
+		}
+		b.WriteString(Number(f))
+		return nil
+	}
+	switch v.Kind() {
+	case reflect.Interface, reflect.Pointer:
+		if v.IsNil() {
+			b.WriteString("null")
+			return nil
+		}
+		return encode(b, v.Elem(), indent, cur)
+	case reflect.Bool:
+		if v.Bool() {
+			b.WriteString("true")
+		} else {
+			b.WriteString("false")
+		}
+	case reflect.String:
+		writeString(b, v.String())
+	case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
+		b.WriteString(Number(float64(v.Int())))
+	case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64:
+		b.WriteString(Number(float64(v.Uint())))
+	case reflect.Float32, reflect.Float64:
+		b.WriteString(Number(v.Float()))
+	case reflect.Slice:
+		if v.IsNil() {
+			// nil-срез — это пустой массив, а не null: в JS неоткуда взяться null вместо []
+			b.WriteString("[]")
+			return nil
+		}
+		fallthrough
+	case reflect.Array:
+		return encodeArray(b, v, indent, cur)
+	case reflect.Map:
+		// В JS порядок ключей — порядок вставки; у Go-map его нет. Разрешаем только
+		// map[string]..., сортируя ключи, — вызывающий отвечает за то, что это совпадает.
+		if v.Type().Key().Kind() != reflect.String {
+			return fmt.Errorf("jsjson: map key must be string, got %s", v.Type().Key())
+		}
+		keys := v.MapKeys()
+		ks := make([]string, len(keys))
+		for i, k := range keys {
+			ks[i] = k.String()
+		}
+		sortStrings(ks)
+		obj := make(Object, 0, len(ks))
+		for _, k := range ks {
+			obj = append(obj, KV{k, v.MapIndex(reflect.ValueOf(k).Convert(v.Type().Key())).Interface()})
+		}
+		return encodeObject(b, obj, indent, cur)
+	case reflect.Struct:
+		return encodeObject(b, structObject(v), indent, cur)
+	default:
+		return fmt.Errorf("jsjson: unsupported kind %s", v.Kind())
+	}
+	return nil
+}
+
+func encodeArray(b *bytes.Buffer, v reflect.Value, indent, cur string) error {
+	n := v.Len()
+	if n == 0 {
+		b.WriteString("[]")
+		return nil
+	}
+	b.WriteByte('[')
+	inner := cur + indent
+	for i := 0; i < n; i++ {
+		if i > 0 {
+			b.WriteByte(',')
+		}
+		if indent != "" {
+			b.WriteByte('\n')
+			b.WriteString(inner)
+		}
+		// undefined/функция в массиве — null; у нас таких нет, кроме nil
+		if err := encode(b, v.Index(i), indent, inner); err != nil {
+			return err
+		}
+	}
+	if indent != "" {
+		b.WriteByte('\n')
+		b.WriteString(cur)
+	}
+	b.WriteByte(']')
+	return nil
+}
+
+// Omit — значение, которое JSON.stringify пропускает (undefined): ключ не выводится.
+type omit struct{}
+
+// Undefined — маркер «ключа нет», как undefined в JS-объекте.
+var Undefined = omit{}
+
+func encodeObject(b *bytes.Buffer, o Object, indent, cur string) error {
+	first := true
+	inner := cur + indent
+	b.WriteByte('{')
+	for _, kv := range o {
+		if _, skip := kv.Val.(omit); skip {
+			continue
+		}
+		if !first {
+			b.WriteByte(',')
+		}
+		first = false
+		if indent != "" {
+			b.WriteByte('\n')
+			b.WriteString(inner)
+		}
+		writeString(b, kv.Key)
+		b.WriteByte(':')
+		if indent != "" {
+			b.WriteByte(' ')
+		}
+		if err := encode(b, reflect.ValueOf(kv.Val), indent, inner); err != nil {
+			return err
+		}
+	}
+	if !first && indent != "" {
+		b.WriteByte('\n')
+		b.WriteString(cur)
+	}
+	b.WriteByte('}')
+	return nil
+}
+
+func structObject(v reflect.Value) Object {
+	t := v.Type()
+	obj := make(Object, 0, t.NumField())
+	for i := 0; i < t.NumField(); i++ {
+		f := t.Field(i)
+		if !f.IsExported() {
+			continue
+		}
+		name := f.Name
+		omitEmpty := false
+		if tag, ok := f.Tag.Lookup("json"); ok {
+			if tag == "-" {
+				continue
+			}
+			parts := strings.Split(tag, ",")
+			if parts[0] != "" {
+				name = parts[0]
+			}
+			for _, p := range parts[1:] {
+				if p == "omitempty" {
+					omitEmpty = true
+				}
+			}
+		}
+		fv := v.Field(i)
+		if omitEmpty && isEmpty(fv) {
+			continue
+		}
+		obj = append(obj, KV{name, fv.Interface()})
+	}
+	return obj
+}
+
+func isEmpty(v reflect.Value) bool {
+	switch v.Kind() {
+	case reflect.Array, reflect.Map, reflect.Slice, reflect.String:
+		return v.Len() == 0
+	case reflect.Bool:
+		return !v.Bool()
+	case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
+		return v.Int() == 0
+	case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64:
+		return v.Uint() == 0
+	case reflect.Float32, reflect.Float64:
+		return v.Float() == 0
+	case reflect.Interface, reflect.Pointer:
+		return v.IsNil()
+	}
+	return false
+}
+
+// writeString экранирует строку как JSON.stringify (ES2019): " \ и управляющие
+// символы; \b \f \n \r \t коротко, прочие < 0x20 — \u00xx строчными. Не трогает
+// / < > & и U+2028/2029. Неверный UTF-8 заменяется на U+FFFD (в JS его не бывает).
+func writeString(b *bytes.Buffer, s string) {
+	b.WriteByte('"')
+	for i := 0; i < len(s); {
+		c := s[i]
+		if c < utf8.RuneSelf {
+			switch c {
+			case '"':
+				b.WriteString(`\"`)
+			case '\\':
+				b.WriteString(`\\`)
+			case '\b':
+				b.WriteString(`\b`)
+			case '\f':
+				b.WriteString(`\f`)
+			case '\n':
+				b.WriteString(`\n`)
+			case '\r':
+				b.WriteString(`\r`)
+			case '\t':
+				b.WriteString(`\t`)
+			default:
+				if c < 0x20 {
+					fmt.Fprintf(b, `\u%04x`, c)
+				} else {
+					b.WriteByte(c)
+				}
+			}
+			i++
+			continue
+		}
+		r, size := utf8.DecodeRuneInString(s[i:])
+		if r == utf8.RuneError && size == 1 {
+			b.WriteString("�")
+		} else {
+			b.WriteString(s[i : i+size])
+		}
+		i += size
+	}
+	b.WriteByte('"')
+}
+
+// Number форматирует число как String(x) в JS (Number::toString), а NaN/±Infinity —
+// как null, что делает JSON.stringify.
+func Number(x float64) string {
+	if math.IsNaN(x) || math.IsInf(x, 0) {
+		return "null"
+	}
+	if x == 0 {
+		return "0" // и -0
+	}
+	neg := x < 0
+	if neg {
+		x = -x
+	}
+	// Кратчайшие цифры, однозначно восстанавливающие x: d.ddddde±n
+	e := strconv.FormatFloat(x, 'e', -1, 64)
+	mant, expStr, _ := strings.Cut(e, "e")
+	digits := strings.Replace(mant, ".", "", 1)
+	exp, _ := strconv.Atoi(expStr)
+	k := len(digits) // число значащих цифр
+	n := exp + 1     // позиция десятичной точки (ECMA-262 Number::toString)
+	var out string
+	switch {
+	case k <= n && n <= 21:
+		out = digits + strings.Repeat("0", n-k)
+	case 0 < n && n <= 21:
+		out = digits[:n] + "." + digits[n:]
+	case -6 < n && n <= 0:
+		out = "0." + strings.Repeat("0", -n) + digits
+	default:
+		sign := "+"
+		if n-1 < 0 {
+			sign = "-"
+		}
+		ee := n - 1
+		if ee < 0 {
+			ee = -ee
+		}
+		if k == 1 {
+			out = digits + "e" + sign + strconv.Itoa(ee)
+		} else {
+			out = digits[:1] + "." + digits[1:] + "e" + sign + strconv.Itoa(ee)
+		}
+	}
+	if neg {
+		return "-" + out
+	}
+	return out
+}
+
+func sortStrings(s []string) {
+	// вставками: ключей мало, а сортировка строк в JS-порядке — по UTF-16, что для
+	// наших ASCII-ключей совпадает с побайтовой
+	for i := 1; i < len(s); i++ {
+		for j := i; j > 0 && s[j] < s[j-1]; j-- {
+			s[j], s[j-1] = s[j-1], s[j]
+		}
+	}
+}
+
+// Get2 — Get без признака наличия (nil, если ключа нет); для цепочек разбора.
+func (o Object) Get2(key string) any {
+	v, _ := o.Get(key)
+	return v
+}

internal/jsjson/jsjson_test.go

@@ -0,0 +1,84 @@
+package jsjson
+
+import (
+	"encoding/json"
+	"os"
+	"testing"
+)
+
+type fixture struct {
+	Strings []struct{ In, Out string } `json:"strings"`
+	Numbers []struct {
+		In  json.RawMessage `json:"in"`
+		Out string          `json:"out"`
+		Str string          `json:"str"`
+	} `json:"numbers"`
+	Objects []struct {
+		In      json.RawMessage `json:"in"`
+		Compact string          `json:"compact"`
+		Indent2 string          `json:"indent2"`
+	} `json:"objects"`
+}
+
+// Эталон — вывод JSON.stringify самого Node (tools/golden/jsjson.mjs).
+func TestAgainstNode(t *testing.T) {
+	raw, err := os.ReadFile("../../testdata/golden/jsjson.json")
+	if err != nil {
+		t.Fatal(err)
+	}
+	var f fixture
+	if err := json.Unmarshal(raw, &f); err != nil {
+		t.Fatal(err)
+	}
+	for _, c := range f.Strings {
+		if got := string(MustMarshal(c.In)); got != c.Out {
+			t.Errorf("string %q: got %s want %s", c.In, got, c.Out)
+		}
+	}
+	for _, c := range f.Numbers {
+		v, err := Decode(c.In)
+		if err != nil {
+			t.Fatal(err)
+		}
+		if s, ok := v.(string); ok { // NaN / Infinity переданы строкой
+			_ = s
+			continue
+		}
+		x := v.(float64)
+		if got := Number(x); got != c.Str {
+			t.Errorf("String(%s): got %s want %s", c.In, got, c.Str)
+		}
+		if got := string(MustMarshal(x)); got != c.Out {
+			t.Errorf("JSON.stringify(%s): got %s want %s", c.In, got, c.Out)
+		}
+	}
+	for _, c := range f.Objects {
+		v, err := Decode(c.In)
+		if err != nil {
+			t.Fatal(err)
+		}
+		if got := string(MustMarshal(v)); got != c.Compact {
+			t.Errorf("compact:\n got %s\nwant %s", got, c.Compact)
+		}
+		got, _ := MarshalIndent(v, "  ")
+		if string(got) != c.Indent2 {
+			t.Errorf("indent:\n got %s\nwant %s", got, c.Indent2)
+		}
+	}
+}
+
+func TestStructOrderAndOmit(t *testing.T) {
+	type S struct {
+		B    string `json:"b"`
+		A    int    `json:"a"`
+		Opt  string `json:"opt,omitempty"`
+		Skip string `json:"-"`
+	}
+	if got := string(MustMarshal(S{B: "x", A: 1})); got != `{"b":"x","a":1}` {
+		t.Fatal(got)
+	}
+	o := Object{{"x", 1}, {"gone", Undefined}, {"y", []string(nil)}}
+	if got := string(MustMarshal(o)); got != `{"x":1,"y":[]}` {
+		t.Fatal(got)
+	}
+}

internal/logx/logx.go

@@ -0,0 +1,60 @@
+// Package logx — простой логгер: человекочитаемые строки в консоль и JSON-строки в
+// файл (как winston в Node-версии: console «<ts> level: msg», файл {level,message,timestamp,…}).
+package logx
+
+import (
+	"encoding/json"
+	"fmt"
+	"io"
+	"os"
+	"path/filepath"
+	"sync"
+	"time"
+)
+
+type Logger struct {
+	mu   sync.Mutex
+	out  io.Writer
+	file *os.File
+}
+
+// New пишет в stdout и (если dir не пуст) в dir/app.log.
+func New(out io.Writer, dir string) *Logger {
+	l := &Logger{out: out}
+	if dir != "" {
+		if err := os.MkdirAll(dir, 0o755); err == nil {
+			if f, err := os.OpenFile(filepath.Join(dir, "app.log"), os.O_APPEND|os.O_CREATE|os.O_WRONLY, 0o644); err == nil {
+				l.file = f
+			}
+		}
+	}
+	return l
+}
+
+func (l *Logger) log(level, msg string, kv []any) {
+	l.mu.Lock()
+	defer l.mu.Unlock()
+	ts := time.Now().UTC().Format("2006-01-02T15:04:05.000Z")
+	if l.out != nil {
+		fmt.Fprintf(l.out, "%s %s: %s\n", ts, level, msg)
+	}
+	if l.file != nil {
+		m := map[string]any{"level": level, "message": msg, "timestamp": ts}
+		for i := 0; i+1 < len(kv); i += 2 {
+			if k, ok := kv[i].(string); ok {
+				if e, isErr := kv[i+1].(error); isErr {
+					m[k] = e.Error()
+				} else {
+					m[k] = kv[i+1]
+				}
+			}
+		}
+		b, _ := json.Marshal(m)
+		l.file.Write(append(b, '\n'))
+	}
+}
+
+func (l *Logger) Info(msg string, kv ...any)  { l.log("info", msg, kv) }
+func (l *Logger) Warn(msg string, kv ...any)  { l.log("warn", msg, kv) }
+func (l *Logger) Error(msg string, kv ...any) { l.log("error", msg, kv) }
+func (l *Logger) Debug(msg string, kv ...any) { l.log("debug", msg, kv) }

internal/ui/audit.go

@@ -0,0 +1,512 @@
+package ui
+
+// Аудит серверов (порт части awg-ui/sub.ts). Периодически core обходит все серверы и ищет
+// «мёртвых» пиров: живы на сервере, хотя панель про них не знает. Сообщает и — если включена
+// очистка или оператор нажал кнопку — снимает подтверждённых: мёртвых два прохода подряд.
+//   ghosts  — есть в ядре (awg show), но неизвестны awg-ctrl;
+//   orphans — есть у awg-ctrl в области этой панели, но панели не нужны (sync их не снял);
+//             key — мастер-ключ пира, если он отозван или удалён.
+// Пиры чужой области в отчёт не попадают — считаются в foreign.
+
+import (
+	"regexp"
+	"strconv"
+	"strings"
+
+	"github.com/maeneko/forgetting/internal/jsjson"
+)
+
+type auditPeer struct {
+	PubKey        string
+	Owner         any // только у orphans
+	Key           any // только у orphans
+	Online        any
+	LastHandshake any
+	SeenBefore    *bool
+	orphan        bool
+}
+
+func (p *auditPeer) json() jsjson.Object {
+	o := jsjson.Object{{Key: "pub_key", Val: p.PubKey}}
+	if p.orphan {
+		o = append(o, jsjson.KV{Key: "owner", Val: p.Owner})
+	}
+	o = append(o, jsjson.KV{Key: "online", Val: p.Online}, jsjson.KV{Key: "lastHandshake", Val: p.LastHandshake})
+	if p.orphan {
+		o = append(o, jsjson.KV{Key: "key", Val: p.Key})
+	}
+	if p.SeenBefore != nil {
+		o = append(o, jsjson.KV{Key: "seen_before", Val: *p.SeenBefore})
+	}
+	return o
+}
+
+type auditEntry struct {
+	ServerID      int
+	Status        string // ok | offline | error
+	GhostsChecked bool   // false — awg-ctrl старше /api/audit, «призраков» не видно
+	Ghosts        []*auditPeer
+	Orphans       []*auditPeer
+	Foreign       int
+	Blocked       *int // очистка отказалась снимать столько пиров разом (предохранитель)
+}
+
+func peersJSON(ps []*auditPeer) []any {
+	out := []any{}
+	for _, p := range ps {
+		out = append(out, p.json())
+	}
+	return out
+}
+
+func (e *auditEntry) json() jsjson.Object {
+	o := jsjson.Object{{Key: "server_id", Val: e.ServerID}, {Key: "status", Val: e.Status}, {Key: "ghosts_checked", Val: e.GhostsChecked},
+		{Key: "ghosts", Val: peersJSON(e.Ghosts)}, {Key: "orphans", Val: peersJSON(e.Orphans)}, {Key: "foreign", Val: e.Foreign}}
+	if e.Blocked != nil {
+		o = append(o, jsjson.KV{Key: "blocked", Val: *e.Blocked})
+	}
+	return o
+}
+
+type auditReport struct {
+	At      int64
+	Servers []*auditEntry
+}
+
+func (r *auditReport) json() any {
+	if r == nil {
+		return nil
+	}
+	list := []any{}
+	for _, e := range r.Servers {
+		list = append(list, e.json())
+	}
+	return jsjson.Object{{Key: "at", Val: r.At}, {Key: "servers", Val: list}}
+}
+
+type cleanedPeer struct {
+	At       int64
+	ServerID int
+	PubKey   string
+	Kind     string // ghost | orphan
+	Key      any    // у ghost нет (undefined)
+	HasKey   bool
+	Auto     bool
+}
+
+func (c cleanedPeer) json() jsjson.Object {
+	o := jsjson.Object{{Key: "at", Val: c.At}, {Key: "server_id", Val: c.ServerID}, {Key: "pub_key", Val: c.PubKey}, {Key: "kind", Val: c.Kind}}
+	if c.HasKey {
+		o = append(o, jsjson.KV{Key: "key", Val: c.Key})
+	}
+	return append(o, jsjson.KV{Key: "auto", Val: c.Auto})
+}
+
+// auditSettings — clean: снимать «мёртвых» сами; every_h — период; max — предохранитель.
+type auditSettings struct {
+	Clean  bool
+	EveryH int
+	Max    int
+}
+
+func (s auditSettings) json() jsjson.Object {
+	return jsjson.Object{{Key: "clean", Val: s.Clean}, {Key: "every_h", Val: s.EveryH}, {Key: "max", Val: s.Max}}
+}
+
+// ── sub_meta: JSON-значения ─────────────────────────────────────────────────
+
+func (s *Sub) metaGet(key string) any {
+	var raw string
+	if s.a.db.QueryRow("SELECT value FROM sub_meta WHERE key = ?", key).Scan(&raw) != nil {
+		return nil
+	}
+	v, err := jsjson.Decode([]byte(raw))
+	if err != nil {
+		return nil
+	}
+	return v
+}
+
+func (s *Sub) metaSet(key string, v any) {
+	s.a.db.Exec("INSERT INTO sub_meta (key, value) VALUES (?, ?) ON CONFLICT(key) DO UPDATE SET value = excluded.value", key, string(jsjson.MustMarshal(v)))
+}
+
+func parsePeer(v any, orphan bool) *auditPeer {
+	o, _ := v.(jsjson.Object)
+	p := &auditPeer{PubKey: strOr(o.Get2("pub_key"), ""), Online: o.Get2("online"), LastHandshake: o.Get2("lastHandshake"), orphan: orphan}
+	if orphan {
+		p.Owner, p.Key = o.Get2("owner"), o.Get2("key")
+	}
+	if b, ok := o.Get2("seen_before").(bool); ok {
+		p.SeenBefore = &b
+	}
+	return p
+}
+
+func parseReport(v any) *auditReport {
+	o, ok := v.(jsjson.Object)
+	if !ok {
+		return nil
+	}
+	r := &auditReport{At: int64(numOr(o.Get2("at"), 0))}
+	for _, x := range arr(o.Get2("servers")) {
+		e := &auditEntry{ServerID: int(numOr(field(x, "server_id"), 0)), Status: strOr(field(x, "status"), "error"),
+			Foreign: int(numOr(field(x, "foreign"), 0))}
+		e.GhostsChecked, _ = field(x, "ghosts_checked").(bool)
+		for _, p := range arr(field(x, "ghosts")) {
+			e.Ghosts = append(e.Ghosts, parsePeer(p, false))
+		}
+		for _, p := range arr(field(x, "orphans")) {
+			e.Orphans = append(e.Orphans, parsePeer(p, true))
+		}
+		if b, ok := field(x, "blocked").(float64); ok {
+			n := int(b)
+			e.Blocked = &n
+		}
+		r.Servers = append(r.Servers, e)
+	}
+	return r
+}
+
+func (s *Sub) loadAudit() {
+	s.lastAudit = parseReport(s.metaGet("audit"))
+	s.auditSettings = auditSettings{Clean: false, EveryH: 1, Max: 10}
+	if o, ok := s.metaGet("audit_settings").(jsjson.Object); ok {
+		if b, ok := o.Get2("clean").(bool); ok {
+			s.auditSettings.Clean = b
+		}
+		if f, ok := o.Get2("every_h").(float64); ok {
+			s.auditSettings.EveryH = int(f)
+		}
+		if f, ok := o.Get2("max").(float64); ok {
+			s.auditSettings.Max = int(f)
+		}
+	}
+	for _, x := range arr(s.metaGet("audit_cleaned")) {
+		o, _ := x.(jsjson.Object)
+		k, hasKey := o.Get("key")
+		auto, _ := o.Get2("auto").(bool)
+		s.cleanedLog = append(s.cleanedLog, cleanedPeer{At: int64(numOr(o.Get2("at"), 0)), ServerID: int(numOr(o.Get2("server_id"), 0)),
+			PubKey: strOr(o.Get2("pub_key"), ""), Kind: strOr(o.Get2("kind"), ""), Key: k, HasKey: hasKey, Auto: auto})
+	}
+}
+
+func (s *Sub) cleanedJSON() []any {
+	out := []any{}
+	for _, c := range s.cleanedLog {
+		out = append(out, c.json())
+	}
+	return out
+}
+
+// ── Проход ──────────────────────────────────────────────────────────────────
+
+var reOwnerMaster = regexp.MustCompile(`^[^/]+/m(\d+)/`)
+
+func (s *Sub) auditNow(id int) (*auditEntry, error) {
+	e := &auditEntry{ServerID: id, Status: "ok", GhostsChecked: true}
+	if !s.a.nodes.Exists(id) || !s.a.nodes.IsOnline(id) {
+		e.Status, e.GhostsChecked = "offline", false
+		return e, nil
+	}
+	ctrl := s.a.nodes.CtrlFor(id)
+	// Сначала обычное сведение: отчёт — про то, что не снялось само.
+	if err := s.reconcileNow(id); err != nil {
+		return nil, err
+	}
+	a, err := ctrl("GET", "/api/audit", nil)
+	if err != nil {
+		return nil, err
+	}
+	p, err := ctrl("GET", "/api/peers", nil)
+	if err != nil {
+		return nil, err
+	}
+	fail := func() (*auditEntry, error) {
+		e.Status, e.GhostsChecked = "error", false
+		e.Ghosts, e.Orphans = nil, nil
+		return e, nil
+	}
+	if !ok2xx(p.Status) {
+		return fail()
+	}
+	if ok2xx(a.Status) {
+		for _, g := range arr(field(a.Data, "ghosts")) {
+			e.Ghosts = append(e.Ghosts, &auditPeer{PubKey: strOr(field(g, "pub_key"), ""), Online: field(g, "online"), LastHandshake: field(g, "lastHandshake")})
+		}
+	} else if a.Status == 404 {
+		e.GhostsChecked = false
+	} else {
+		return fail()
+	}
+
+	keep := map[string]bool{}
+	for _, k := range s.keepOf(id) {
+		keep[k] = true
+	}
+	prefix := s.panelID + "/"
+	for _, peer := range arr(field(p.Data, "peers")) {
+		owner, ok := field(peer, "owner").(string)
+		if !ok {
+			return nil, errTypeError // peer.owner.startsWith бросил бы TypeError
+		}
+		pub := strOr(field(peer, "pub_key"), "")
+		if !strings.HasPrefix(owner, prefix) {
+			if strings.Contains(owner, "/") {
+				e.Foreign++
+			}
+			continue
+		}
+		if keep[pub] {
+			continue
+		}
+		key := any("(нет в ui.db)")
+		if m := reOwnerMaster.FindStringSubmatch(owner); m != nil {
+			if mid, err := strconv.ParseInt(m[1], 10, 64); err == nil && mid <= 9007199254740991 {
+				if row := s.masterRowByID(s.a.db, mid); row != nil {
+					if row.RevokedAt.Valid {
+						key = row.Label + " (удалён)"
+					} else {
+						key = row.Label
+					}
+				}
+			}
+		}
+		e.Orphans = append(e.Orphans, &auditPeer{PubKey: pub, Owner: owner, Online: field(peer, "online"),
+			LastHandshake: field(peer, "lastHandshake"), Key: key, orphan: true})
+	}
+	return e, nil
+}
+
+type jsTypeError struct{}
+
+func (jsTypeError) Error() string { return "TypeError" }
+
+var errTypeError = jsTypeError{}
+
+// audit — под той же блокировкой, что и сведение: пир, которого прямо сейчас добавляет проход, не «призрак».
+func (s *Sub) audit(id int) *auditEntry {
+	l := s.lock(id)
+	l.Lock()
+	defer l.Unlock()
+	e, err := func() (e *auditEntry, err error) {
+		defer func() {
+			if recover() != nil {
+				e, err = nil, errTypeError
+			}
+		}()
+		return s.auditNow(id)
+	}()
+	if err != nil || e == nil {
+		return &auditEntry{ServerID: id, Status: "error"}
+	}
+	return e
+}
+
+// cleanEntry — снять «мёртвых» сервера: только подтверждённых (seen_before), не больше max за проход.
+// «Призраки» — через awg-ctrl (он сам перепроверяет ключи), лишние — обычным DELETE.
+func (s *Sub) cleanEntry(e *auditEntry, auto bool) error {
+	seen := func(ps []*auditPeer) []*auditPeer {
+		var out []*auditPeer
+		for _, p := range ps {
+			if p.SeenBefore != nil && *p.SeenBefore {
+				out = append(out, p)
+			}
+		}
+		return out
+	}
+	ghosts, orphans := seen(e.Ghosts), seen(e.Orphans)
+	if len(ghosts)+len(orphans) == 0 || e.Status != "ok" {
+		return nil
+	}
+	s.auditMu.Lock()
+	max := s.auditSettings.Max
+	s.auditMu.Unlock()
+	if auto && len(ghosts)+len(orphans) > max {
+		n := len(ghosts) + len(orphans)
+		e.Blocked = &n
+		warnf("sub: очистка сервера #%d пропущена: %d пиров больше предела %d", e.ServerID, n, max)
+		return nil
+	}
+	ctrl := s.a.nodes.CtrlFor(e.ServerID)
+	var done []cleanedPeer
+	log := func(p *auditPeer, kind string) {
+		done = append(done, cleanedPeer{At: now(), ServerID: e.ServerID, PubKey: p.PubKey, Kind: kind, Key: p.Key, HasKey: p.orphan, Auto: auto})
+	}
+	if len(ghosts) > 0 {
+		keys := []any{}
+		for _, g := range ghosts {
+			keys = append(keys, g.PubKey)
+		}
+		r, err := ctrl("POST", "/api/audit/clean", jsjson.Object{{Key: "pub_keys", Val: keys}})
+		if err != nil {
+			return err
+		}
+		if ok2xx(r.Status) {
+			removed := map[string]bool{}
+			for _, x := range arr(field(r.Data, "removed")) {
+				if k, ok := x.(string); ok {
+					removed[k] = true
+				}
+			}
+			for _, g := range ghosts {
+				if removed[g.PubKey] {
+					log(g, "ghost")
+				}
+			}
+		}
+	}
+	for _, p := range orphans {
+		r, err := ctrl("DELETE", "/api/peers/"+pubParam(p.PubKey), nil)
+		if err != nil {
+			return err
+		}
+		if ok2xx(r.Status) || r.Status == 404 {
+			log(p, "orphan")
+		} else if gone(r.Status) {
+			break
+		}
+	}
+	if len(done) == 0 {
+		return nil
+	}
+	cleaned := map[string]bool{}
+	var short []string
+	for _, d := range done {
+		cleaned[d.PubKey] = true
+		k := d.PubKey
+		if len(k) > 8 {
+			k = k[:8]
+		}
+		short = append(short, k)
+	}
+	drop := func(ps []*auditPeer) []*auditPeer {
+		var out []*auditPeer
+		for _, p := range ps {
+			if !cleaned[p.PubKey] {
+				out = append(out, p)
+			}
+		}
+		return out
+	}
+	e.Ghosts, e.Orphans = drop(e.Ghosts), drop(e.Orphans)
+	s.auditMu.Lock()
+	s.cleanedLog = append(done, s.cleanedLog...)
+	if len(s.cleanedLog) > 100 {
+		s.cleanedLog = s.cleanedLog[:100]
+	}
+	s.metaSet("audit_cleaned", s.cleanedJSON())
+	s.auditMu.Unlock()
+	what := "очистка"
+	if auto {
+		what = "автоочистка"
+	}
+	warnf("sub: %s сервера #%d: снято %d (%s)", what, e.ServerID, len(done), strings.Join(short, ", "))
+	return nil
+}
+
+// cleanLocked — очистка под блокировкой сервера, как и сам аудит.
+func (s *Sub) cleanLocked(e *auditEntry, auto bool) {
+	l := s.lock(e.ServerID)
+	l.Lock()
+	defer l.Unlock()
+	if err := s.cleanEntry(e, auto); err != nil && auto {
+		warnf("sub: очистка сервера #%d не удалась: %v", e.ServerID, err)
+	}
+}
+
+// auditAll — проход по всем серверам; одновременно идёт не больше одного (повторный вызов ждёт
+// текущий). auto — плановый: очищает сам, если включено. Ручной только смотрит.
+func (s *Sub) auditAll(auto bool) {
+	s.auditMu.Lock()
+	if ch := s.auditing; ch != nil {
+		s.auditMu.Unlock()
+		<-ch
+		return
+	}
+	ch := make(chan struct{})
+	s.auditing = ch
+	prev := s.lastAudit
+	s.auditMu.Unlock()
+	defer func() {
+		s.auditMu.Lock()
+		s.auditing = nil
+		s.auditMu.Unlock()
+		close(ch)
+	}()
+
+	ids := s.a.nodes.IDs()
+	report := &auditReport{At: now(), Servers: make([]*auditEntry, len(ids))}
+	done := make(chan struct{}, len(ids))
+	for i, id := range ids {
+		go func() { report.Servers[i] = s.audit(id); done <- struct{}{} }()
+	}
+	for range ids {
+		<-done
+	}
+	s.auditMu.Lock()
+	clean := s.auditSettings.Clean
+	s.auditMu.Unlock()
+	for _, e := range report.Servers {
+		was := map[string]bool{}
+		if prev != nil {
+			for _, x := range prev.Servers {
+				if x.ServerID == e.ServerID {
+					for _, p := range append(append([]*auditPeer{}, x.Ghosts...), x.Orphans...) {
+						was[p.PubKey] = true
+					}
+					break
+				}
+			}
+		}
+		for _, p := range append(append([]*auditPeer{}, e.Ghosts...), e.Orphans...) {
+			b := was[p.PubKey]
+			p.SeenBefore = &b
+		}
+		if auto && clean {
+			s.cleanLocked(e, true)
+		}
+	}
+	s.auditMu.Lock()
+	s.lastAudit = report
+	s.metaSet("audit", report.json())
+	s.auditMu.Unlock()
+	for _, e := range report.Servers {
+		if e.Status == "error" {
+			warnf("sub: аудит сервера #%d не удался", e.ServerID)
+		}
+		if n := len(e.Ghosts) + len(e.Orphans); n > 0 {
+			online := 0
+			for _, p := range append(append([]*auditPeer{}, e.Ghosts...), e.Orphans...) {
+				if truthy(p.Online) {
+					online++
+				}
+			}
+			warnf("sub: аудит сервера #%d: мёртвых пиров %d (в ядре без записи: %d, лишних у awg-ctrl: %d, онлайн: %d)",
+				e.ServerID, n, len(e.Ghosts), len(e.Orphans), online)
+		}
+	}
+}
+
+// cleanNow — ручная очистка подтверждённых «мёртвых» по последнему отчёту.
+func (s *Sub) cleanNow() {
+	s.auditMu.Lock()
+	rep := s.lastAudit
+	s.auditMu.Unlock()
+	if rep == nil {
+		return
+	}
+	for _, e := range rep.Servers {
+		s.cleanLocked(e, false)
+	}
+	s.auditMu.Lock()
+	s.metaSet("audit", rep.json())
+	s.auditMu.Unlock()
+}
+
+func (s *Sub) auditState() jsjson.Object {
+	s.auditMu.Lock()
+	defer s.auditMu.Unlock()
+	return jsjson.Object{{Key: "enabled", Val: s.auditOn}, {Key: "settings", Val: s.auditSettings.json()},
+		{Key: "report", Val: s.lastAudit.json()}, {Key: "cleaned", Val: s.cleanedJSON()}}
+}

internal/ui/jsutil.go

@@ -0,0 +1,122 @@
+package ui
+
+import (
+	"io"
+	"log"
+	"math"
+	"net/http"
+	"strconv"
+	"strings"
+	"unicode/utf16"
+)
+
+// jsToNumber — Number(s) для строки: пробелы по краям, пусто → 0, 0x/0o/0b, Infinity;
+// всё прочее нечисловое — NaN.
+func jsToNumber(s string) float64 {
+	t := strings.TrimSpace(s)
+	if t == "" {
+		return 0
+	}
+	switch t {
+	case "Infinity", "+Infinity":
+		return math.Inf(1)
+	case "-Infinity":
+		return math.Inf(-1)
+	}
+	if len(t) > 2 && t[0] == '0' {
+		base := 0
+		switch t[1] {
+		case 'x', 'X':
+			base = 16
+		case 'o', 'O':
+			base = 8
+		case 'b', 'B':
+			base = 2
+		}
+		if base != 0 {
+			n, err := strconv.ParseUint(t[2:], base, 64)
+			if err != nil {
+				return math.NaN()
+			}
+			return float64(n)
+		}
+	}
+	for _, r := range t {
+		if !(r >= '0' && r <= '9' || r == '.' || r == 'e' || r == 'E' || r == '+' || r == '-') {
+			return math.NaN()
+		}
+	}
+	f, err := strconv.ParseFloat(t, 64)
+	if err != nil {
+		return math.NaN()
+	}
+	return f
+}
+
+// jsToNumberAny — Number(v) для значения из JSON.
+func jsToNumberAny(v any) float64 {
+	switch x := v.(type) {
+	case nil:
+		return 0
+	case bool:
+		if x {
+			return 1
+		}
+		return 0
+	case float64:
+		return x
+	case string:
+		return jsToNumber(x)
+	}
+	return math.NaN()
+}
+
+// encodeURIComponent — как в JS: не трогает A-Z a-z 0-9 - _ . ! ~ * ' ( ).
+func encodeURIComponent(s string) string {
+	const hexd = "0123456789ABCDEF"
+	var b strings.Builder
+	for i := 0; i < len(s); i++ {
+		c := s[i]
+		if c >= 'A' && c <= 'Z' || c >= 'a' && c <= 'z' || c >= '0' && c <= '9' || strings.IndexByte("-_.!~*'()", c) >= 0 {
+			b.WriteByte(c)
+		} else {
+			b.WriteByte('%')
+			b.WriteByte(hexd[c>>4])
+			b.WriteByte(hexd[c&15])
+		}
+	}
+	return b.String()
+}
+
+func readAll(resp *http.Response) ([]byte, error) { return io.ReadAll(resp.Body) }
+
+// utf16Len — длина строки в JS (кодовые единицы UTF-16).
+func utf16Len(s string) int {
+	n := 0
+	for _, r := range s {
+		if r >= 0x10000 {
+			n += 2
+		} else {
+			n++
+		}
+	}
+	return n
+}
+
+// lenOK — `{min,max}` в JS-регулярке над строкой целиком: длина в единицах UTF-16.
+func lenOK(s string, min, max int) bool {
+	n := utf16Len(s)
+	return n >= min && n <= max
+}
+
+// sliceUTF16 — s.slice(0, n) в JS. Разрезанная суррогатная пара при записи в SQLite
+// превращается в U+FFFD — так же делаем и здесь.
+func sliceUTF16(s string, n int) string {
+	units := utf16.Encode([]rune(s))
+	if len(units) <= n {
+		return s
+	}
+	return string(utf16.Decode(units[:n]))
+}
+
+func quietLog() *log.Logger { return log.New(io.Discard, "", 0) }

internal/ui/metrics.go

@@ -0,0 +1,484 @@
+package ui
+
+// Prometheus: GET /metrics на ядре (порт awg-ui/metrics.ts). Метрики ядра и всех нод
+// собираются здесь же — у нод через уже открытый WSS. Доступ — отдельный токен «только чтение
+// метрик»; он не открывает ни /api/v1, ни панель.
+
+import (
+	"bytes"
+	"crypto/rand"
+	"crypto/sha256"
+	"crypto/subtle"
+	"database/sql"
+	"encoding/hex"
+	"math"
+	"os"
+	"regexp"
+	"strings"
+	"sync"
+	"time"
+
+	"github.com/maeneko/forgetting/internal/jsjson"
+)
+
+const (
+	scrapeDeadline = 5 * time.Second
+	touchEveryS    = 60 // last_used пишем не чаще раза в минуту, а не на каждый скрейп
+)
+
+func hashToken(t string) []byte {
+	s := sha256.Sum256([]byte(t))
+	return s[:]
+}
+
+type Metrics struct {
+	a         *App
+	perPeer   bool
+	localFile string
+
+	mu        sync.Mutex
+	localMod  time.Time
+	localSeen bool
+	localHash []byte
+}
+
+func newMetrics(a *App) (*Metrics, error) {
+	m := &Metrics{
+		a: a,
+		// Пер-пировые серии (peer = внутренний IP, name = имя пользователя) выключены: это и
+		// приватность, и кардинальность. Включается явно.
+		perPeer:   strings.ToLower(envOr("METRICS_PEERS", "off")) == "on",
+		localFile: envOr("MONITOR_HASH_FILE", "/etc/amnezia/amneziawg/monitor_token.sha256"),
+	}
+	_, err := a.db.Exec(`
+        CREATE TABLE IF NOT EXISTS metrics_token (
+            id         INTEGER PRIMARY KEY CHECK (id = 1),
+            token_hash BLOB    NOT NULL,
+            prefix     TEXT    NOT NULL,
+            created_at INTEGER NOT NULL,
+            last_used  INTEGER
+        )
+    `)
+	return m, err
+}
+
+var reHex64 = regexp.MustCompile(`^[0-9a-f]{64}$`)
+
+// localTokenHash — токен встроенного Prometheus (`awg-ctrl monitor install`): здесь его хэш.
+// Файл перечитывается по mtime: установка не требует перезапуска панели.
+func (m *Metrics) localTokenHash() []byte {
+	m.mu.Lock()
+	defer m.mu.Unlock()
+	st, err := os.Stat(m.localFile)
+	if err != nil {
+		m.localSeen, m.localHash = false, nil
+		return nil
+	}
+	if !m.localSeen || !st.ModTime().Equal(m.localMod) {
+		raw, err := os.ReadFile(m.localFile)
+		if err != nil {
+			m.localSeen, m.localHash = false, nil
+			return nil
+		}
+		m.localSeen, m.localMod, m.localHash = true, st.ModTime(), nil
+		if h := strings.TrimSpace(string(raw)); reHex64.MatchString(h) {
+			m.localHash, _ = hex.DecodeString(h)
+		}
+	}
+	return m.localHash
+}
+
+type tokenRow struct {
+	hash      []byte
+	prefix    string
+	createdAt int64
+	lastUsed  sql.NullInt64
+}
+
+func (m *Metrics) token() *tokenRow {
+	t := &tokenRow{}
+	if m.a.db.QueryRow("SELECT token_hash, prefix, created_at, last_used FROM metrics_token WHERE id = 1").Scan(&t.hash, &t.prefix, &t.createdAt, &t.lastUsed) != nil {
+		return nil
+	}
+	return t
+}
+
+func (m *Metrics) view() jsjson.Object {
+	if t := m.token(); t != nil {
+		return jsjson.Object{{Key: "exists", Val: true}, {Key: "prefix", Val: t.prefix}, {Key: "created_at", Val: t.createdAt},
+			{Key: "last_used", Val: nullInt(t.lastUsed)}, {Key: "per_peer", Val: m.perPeer}}
+	}
+	return jsjson.Object{{Key: "exists", Val: false}, {Key: "per_peer", Val: m.perPeer}}
+}
+
+// router — управление токеном (роуты панели, за JWT). Выпуск и перевыпуск — одно и то же:
+// старый токен перестаёт работать. Значение отдаётся один раз.
+func (m *Metrics) router() *Router {
+	rt := newRouter()
+	rt.Get("/", func(c *Ctx) bool { return c.JSON(200, m.view()) })
+	rt.Post("/", func(c *Ctx) bool {
+		b := make([]byte, 24)
+		rand.Read(b)
+		tok := "awgm_" + b64url.EncodeToString(b)
+		m.a.db.Exec("INSERT OR REPLACE INTO metrics_token (id, token_hash, prefix, created_at, last_used) VALUES (1, ?, ?, ?, NULL)",
+			hashToken(tok), tok[:13]+"…", now())
+		return c.JSON(201, append(m.view(), jsjson.KV{Key: "token", Val: tok}))
+	})
+	rt.Delete("/", func(c *Ctx) bool {
+		m.a.db.Exec("DELETE FROM metrics_token WHERE id = 1")
+		return c.JSON(200, m.view())
+	})
+	return rt
+}
+
+func writeText(c *Ctx, status int, ctype, body string) bool {
+	c.W.Header().Set("Content-Type", ctype)
+	c.W.WriteHeader(status)
+	c.W.Write([]byte(body))
+	return false
+}
+
+// requireToken — нет токена или он неверный — одинаковый 401: не подсказываем, выключены
+// метрики или токен не тот.
+func (m *Metrics) requireToken(c *Ctx) bool {
+	given := bearer(c.R)
+	row := m.token()
+	var gh []byte
+	if strings.HasPrefix(given, "awgm_") {
+		gh = hashToken(given)
+	}
+	panelOK := row != nil && gh != nil && len(row.hash) == len(gh) && subtle.ConstantTimeCompare(gh, row.hash) == 1
+	local := m.localTokenHash()
+	localOK := gh != nil && local != nil && subtle.ConstantTimeCompare(gh, local) == 1
+	if !panelOK && !localOK {
+		c.W.Header().Set("WWW-Authenticate", "Bearer")
+		return writeText(c, 401, "text/plain; charset=utf-8", "unauthorized\n")
+	}
+	// last_used — про токен, выпущенный в панели (внешний Prometheus); встроенный в нём не участвует.
+	if t := now(); panelOK && (!row.lastUsed.Valid || row.lastUsed.Int64 == 0 || t-row.lastUsed.Int64 >= touchEveryS) {
+		m.a.db.Exec("UPDATE metrics_token SET last_used = ? WHERE id = 1", t)
+	}
+	return true
+}
+
+// ── Экспозиция ──────────────────────────────────────────────────────────────
+
+type label struct {
+	k string
+	v any
+}
+
+type sample struct {
+	labels []label
+	v      any // число; не число и не конечное — 0
+}
+
+type exposition struct {
+	b    bytes.Buffer
+	seen map[string]bool
+}
+
+var (
+	escLabel = strings.NewReplacer(`\`, `\\`, "\n", `\n`, `"`, `\"`)
+	escHelp  = strings.NewReplacer(`\`, `\\`, "\n", `\n`)
+)
+
+// labelString — String(v) для значения метки.
+func labelString(v any) string {
+	switch x := v.(type) {
+	case string:
+		return x
+	case int:
+		return jsjson.Number(float64(x))
+	case int64:
+		return jsjson.Number(float64(x))
+	case float64:
+		return jsjson.Number(x)
+	case bool:
+		if x {
+			return "true"
+		}
+		return "false"
+	case nil:
+		return "undefined"
+	}
+	return "[object Object]"
+}
+
+func (e *exposition) add(name, typ, help string, samples []sample) {
+	if len(samples) == 0 {
+		return
+	}
+	if !e.seen[name] {
+		e.seen[name] = true
+		e.b.WriteString("# HELP " + name + " " + escHelp.Replace(help) + "\n# TYPE " + name + " " + typ + "\n")
+	}
+	for _, s := range samples {
+		e.b.WriteString(name)
+		if len(s.labels) > 0 {
+			parts := make([]string, len(s.labels))
+			for i, l := range s.labels {
+				parts[i] = l.k + `="` + escLabel.Replace(labelString(l.v)) + `"`
+			}
+			e.b.WriteString("{" + strings.Join(parts, ",") + "}")
+		}
+		v := 0.0
+		switch x := s.v.(type) {
+		case float64:
+			v = x
+		case int:
+			v = float64(x)
+		case int64:
+			v = float64(x)
+		}
+		if math.IsNaN(v) || math.IsInf(v, 0) {
+			v = 0
+		}
+		e.b.WriteString(" " + jsjson.Number(v) + "\n")
+	}
+}
+
+func b2f(b bool) float64 {
+	if b {
+		return 1
+	}
+	return 0
+}
+
+// scrapeServer — один сервер за скрейп: сам сервер не отвечает — остальные не страдают.
+func (m *Metrics) scrapeServer(s serverInfo) any {
+	if s.Pending || !m.a.nodes.IsOnline(s.ID) {
+		return nil
+	}
+	ch := make(chan any, 1)
+	go func() {
+		r, err := m.a.nodes.CtrlFor(s.ID)("GET", "/api/metrics", nil)
+		if err != nil || r.Status != 200 {
+			ch <- nil
+			return
+		}
+		ch <- r.Data
+	}()
+	select {
+	case d := <-ch:
+		return d
+	case <-time.After(scrapeDeadline):
+		return nil
+	}
+}
+
+func (m *Metrics) render() string {
+	t0 := time.Now()
+	list := m.a.nodes.List()
+	data := make([]any, len(list))
+	var wg sync.WaitGroup
+	for i, s := range list {
+		wg.Add(1)
+		go func() { defer wg.Done(); data[i] = m.scrapeServer(s) }()
+	}
+	wg.Wait()
+	out := &exposition{seen: map[string]bool{}}
+	L := func(s serverInfo, extra ...label) []label {
+		return append([]label{{"server", s.Name}, {"server_id", s.ID}}, extra...)
+	}
+	// Серии только тех серверов, чьи метрики получены.
+	per := func(fn func(s serverInfo, d any) []sample) []sample {
+		var res []sample
+		for i, s := range list {
+			if truthy(data[i]) {
+				res = append(res, fn(s, data[i])...)
+			}
+		}
+		return res
+	}
+	one := func(fn func(d any) any) func(serverInfo, any) []sample {
+		return func(s serverInfo, d any) []sample { return []sample{{L(s), fn(d)}} }
+	}
+	or0 := func(v any) any {
+		if v == nil {
+			return 0.0
+		}
+		return v
+	}
+
+	out.add("awg_panel_info", "gauge", "Версия панели Forgetting.", []sample{{[]label{{"version", m.a.version}}, 1.0}})
+	out.add("awg_servers", "gauge", "Серверов в панели (ядро и ноды).", []sample{{nil, float64(len(list))}})
+	var online, scrapeOK, info []sample
+	for i, s := range list {
+		online = append(online, sample{L(s), b2f(s.Online)})
+		scrapeOK = append(scrapeOK, sample{L(s), b2f(truthy(data[i]))})
+		if !s.Pending {
+			gen, module, tools := any(""), any(""), any("")
+			if s.Health != nil {
+				gen, module, tools = s.Health.Gen, s.Health.Module, s.Health.Tools
+			}
+			ver := s.Version
+			if ver == nil {
+				ver = ""
+			}
+			info = append(info, sample{L(s, label{"version", ver}, label{"gen", gen}, label{"module", module}, label{"tools", tools}), 1.0})
+		}
+	}
+	out.add("awg_server_online", "gauge", "Сервер на связи с панелью (1/0).", online)
+	out.add("awg_scrape_ok", "gauge", "Метрики сервера получены в этом скрейпе (1/0).", scrapeOK)
+	out.add("awg_node_info", "gauge", "Версия Forgetting и поколение AWG на сервере.", info)
+
+	out.add("awg_up", "gauge", "Интерфейс AWG поднят (1/0).", per(one(func(d any) any { return b2f(truthy(field(d, "up"))) })))
+	out.add("awg_peers", "gauge", "Пиров в интерфейсе.", per(one(func(d any) any { return or0(field(d, "peers", "total")) })))
+	out.add("awg_peers_online", "gauge", "Пиров с рукопожатием за последние 3 минуты.", per(one(func(d any) any { return or0(field(d, "peers", "online")) })))
+	// Сумма по пирам — gauge, а не counter: при удалении пира сумма уменьшается.
+	out.add("awg_peers_received_bytes", "gauge", "Принято от клиентов (их отдача), байт, сумма по пирам. Уменьшается при удалении пира.", per(one(func(d any) any { return or0(field(d, "rx_bytes")) })))
+	out.add("awg_peers_sent_bytes", "gauge", "Отправлено клиентам (их загрузка), байт, сумма по пирам. Уменьшается при удалении пира.", per(one(func(d any) any { return or0(field(d, "tx_bytes")) })))
+	for _, x := range [][3]string{
+		{"rx_bytes", "receive_bytes", "байт"}, {"tx_bytes", "transmit_bytes", "байт"},
+		{"rx_packets", "receive_packets", "пакетов"}, {"tx_packets", "transmit_packets", "пакетов"},
+		{"rx_dropped", "receive_dropped", "потерянных пакетов"}, {"tx_dropped", "transmit_dropped", "потерянных пакетов"},
+		{"rx_errors", "receive_errors", "ошибок"}, {"tx_errors", "transmit_errors", "ошибок"},
+	} {
+		out.add("awg_link_"+x[1]+"_total", "counter", "Интерфейс awg1: "+x[2]+" ("+x[0]+").", per(one(func(d any) any { return or0(field(d, "link", x[0])) })))
+	}
+
+	// Нагрузка хоста. CPU — счётчики секунд по режимам: доля = rate() в Prometheus.
+	out.add("awg_host_cpu_seconds_total", "counter", "Время процессора по режимам, секунд (как node_exporter).",
+		per(func(s serverInfo, d any) []sample {
+			cpu, _ := field(d, "host", "cpu").(jsjson.Object)
+			var res []sample
+			for _, kv := range cpu {
+				res = append(res, sample{L(s, label{"mode", kv.Key}), jsToNumberAny(kv.Val)})
+			}
+			return res
+		}))
+	hostOne := func(fn func(h any) any) func(serverInfo, any) []sample {
+		return func(s serverInfo, d any) []sample {
+			h := field(d, "host")
+			if !truthy(h) {
+				return nil
+			}
+			return []sample{{L(s), fn(h)}}
+		}
+	}
+	out.add("awg_host_cpu_cores", "gauge", "Ядер процессора.", per(hostOne(func(h any) any { return or0(field(h, "cores")) })))
+	out.add("awg_host_memory_total_bytes", "gauge", "Оперативной памяти всего, байт.", per(hostOne(func(h any) any { return or0(field(h, "mem", "total")) })))
+	out.add("awg_host_memory_available_bytes", "gauge", "Доступной памяти (MemAvailable), байт.", per(hostOne(func(h any) any { return or0(field(h, "mem", "available")) })))
+	out.add("awg_host_load", "gauge", "Средняя загрузка системы (load average).", per(func(s serverInfo, d any) []sample {
+		h := field(d, "host")
+		if !truthy(h) {
+			return nil
+		}
+		load := arr(field(h, "load"))
+		var res []sample
+		for i, p := range []string{"1m", "5m", "15m"} {
+			var v any = 0.0
+			if i < len(load) && load[i] != nil {
+				v = load[i]
+			}
+			res = append(res, sample{L(s, label{"period", p}), v})
+		}
+		return res
+	}))
+
+	// Деление канала (CAKE)
+	sh := func(fn func(x any) any) []sample {
+		return per(func(s serverInfo, d any) []sample {
+			x := field(d, "shaping")
+			if !truthy(x) {
+				return nil
+			}
+			return []sample{{L(s), fn(x)}}
+		})
+	}
+	out.add("awg_shaping_enabled", "gauge", "Деление канала включено в настройках (1/0).", sh(func(x any) any { return b2f(truthy(field(x, "settings", "enabled"))) }))
+	out.add("awg_shaping_active", "gauge", "CAKE реально стоит на интерфейсе (1/0).", sh(func(x any) any { return b2f(truthy(field(x, "active"))) }))
+	out.add("awg_shaping_congested", "gauge", "Канал считается перегруженным (1/0).", sh(func(x any) any { return b2f(truthy(field(x, "congested"))) }))
+	out.add("awg_shaping_heavy_devices", "gauge", "Устройств в фоновом классе.", sh(func(x any) any {
+		if h, ok := field(x, "heavy").([]any); ok {
+			return float64(len(h))
+		}
+		return 0.0
+	}))
+	out.add("awg_shaping_active_devices", "gauge", "Активных устройств в окне наблюдения.", sh(func(x any) any { return or0(field(x, "devices")) }))
+	// dirs — значение nil (undefined) серию не даёт.
+	dirs := func(fn func(x any, dir string) any) []sample {
+		return per(func(s serverInfo, d any) []sample {
+			x := field(d, "shaping")
+			if !truthy(x) {
+				return nil
+			}
+			var res []sample
+			for _, dir := range []string{"down", "up"} {
+				if v := fn(x, dir); v != nil {
+					res = append(res, sample{L(s, label{"direction", dir}), v})
+				}
+			}
+			return res
+		})
+	}
+	mbit := func(v any) any {
+		if v == nil {
+			return math.NaN() // undefined * 1e6
+		}
+		return jsToNumberAny(v) * 1e6
+	}
+	out.add("awg_shaping_bandwidth_bits", "gauge", "Заданная ширина канала, бит/с.", dirs(func(x any, dir string) any {
+		if dir == "down" {
+			return mbit(field(x, "settings", "downMbit"))
+		}
+		return mbit(field(x, "settings", "upMbit"))
+	}))
+	out.add("awg_shaping_rate_bits", "gauge", "Скорость за последний тик сэмплера, бит/с.", dirs(func(x any, dir string) any {
+		if dir == "down" {
+			return mbit(field(x, "rateDown"))
+		}
+		return mbit(field(x, "rateUp"))
+	}))
+	out.add("awg_shaping_qdisc_drops_total", "counter", "Пакетов, отброшенных CAKE.", dirs(func(x any, dir string) any { return field(x, dir, "drops") }))
+	out.add("awg_shaping_qdisc_backlog_bytes", "gauge", "Байт в очереди CAKE.", dirs(func(x any, dir string) any { return field(x, dir, "backlog") }))
+
+	// Блокировка BitTorrent
+	tb := func(fn func(x any) any) []sample {
+		return per(func(s serverInfo, d any) []sample {
+			x := field(d, "torrent")
+			if !truthy(x) {
+				return nil
+			}
+			return []sample{{L(s), fn(x)}}
+		})
+	}
+	out.add("awg_torrent_block_enabled", "gauge", "Блокировка BitTorrent включена в настройках (1/0).", tb(func(x any) any { return b2f(truthy(field(x, "settings", "enabled"))) }))
+	out.add("awg_torrent_block_active", "gauge", "nft-таблица блокировки реально стоит (1/0).", tb(func(x any) any { return b2f(truthy(field(x, "active"))) }))
+	out.add("awg_torrent_blocked_total", "counter", "Заблокированных попыток торрент-соединений с последнего применения правил.", tb(func(x any) any { return or0(field(x, "hits")) }))
+	out.add("awg_torrent_devices", "gauge", "Устройств, пытавшихся качать торренты за последние 10 минут.", tb(func(x any) any { return float64(len(arr(field(x, "seen")))) }))
+
+	if m.perPeer {
+		peers := func(fn func(p any) any) []sample {
+			return per(func(s serverInfo, d any) []sample {
+				var res []sample
+				for _, p := range arr(field(d, "list")) {
+					name := field(p, "name")
+					if name == nil {
+						name = ""
+					}
+					res = append(res, sample{L(s, label{"peer", field(p, "ip")}, label{"name", name}, label{"kind", field(p, "kind")}), fn(p)})
+				}
+				return res
+			})
+		}
+		out.add("awg_peer_online", "gauge", "Пир на связи (1/0).", peers(func(p any) any { return b2f(truthy(field(p, "online"))) }))
+		out.add("awg_peer_background", "gauge", "Пир в фоновом классе: канал занят, а он давно качает больше своей доли (1/0).", peers(func(p any) any { return b2f(field(p, "priority") == "background") }))
+		out.add("awg_peer_torrent", "gauge", "Пир пытался открыть торрент-соединение за последние 10 минут (1/0).", peers(func(p any) any { return b2f(truthy(field(p, "torrent"))) }))
+		out.add("awg_peer_received_bytes_total", "counter", "Принято от пира, байт.", peers(func(p any) any { return field(p, "rx") }))
+		out.add("awg_peer_sent_bytes_total", "counter", "Отправлено пиру, байт.", peers(func(p any) any { return field(p, "tx") }))
+	}
+
+	var masters, devices int64
+	m.a.db.QueryRow("SELECT COUNT(*) AS n FROM master_keys WHERE revoked_at IS NULL").Scan(&masters)
+	m.a.db.QueryRow("SELECT COUNT(*) AS n FROM devices").Scan(&devices)
+	out.add("awg_master_keys", "gauge", "Мастер-ключей sen:// (без удаляемых).", []sample{{nil, masters}})
+	out.add("awg_devices", "gauge", "Устройств sen://.", []sample{{nil, devices}})
+	out.add("awg_scrape_duration_seconds", "gauge", "Сколько панель собирала метрики.", []sample{{nil, time.Since(t0).Seconds()}})
+	return out.b.String()
+}
+
+func (m *Metrics) handler(c *Ctx) bool {
+	return writeText(c, 200, "text/plain; version=0.0.4; charset=utf-8", m.render())
+}

internal/ui/monitor.go

@@ -0,0 +1,427 @@
+package ui
+
+// Вкладка «Монитор» (порт awg-ui/monitor.ts): встроенный Prometheus и основные графики.
+//   GET  /ui/monitor            — готов ли Prometheus, можно ли поставить его кнопкой, ход установки
+//   POST /ui/monitor/install    — попросить локальный awg-ctrl выполнить `awg-ctrl monitor install` (root)
+//   POST /ui/monitor/remove     — то же для `awg-ctrl monitor remove`
+//   GET  /ui/monitor/overview   — серии для графиков за 1 ч / 6 ч / 24 ч / 7 дн / 30 дн
+// Панель сама пакетов не ставит и в Prometheus ходит только фиксированными запросами.
+
+import (
+	"errors"
+	"io"
+	"math"
+	"net/http"
+	"net/url"
+	"sort"
+	"strconv"
+	"strings"
+	"sync"
+	"time"
+
+	"github.com/maeneko/forgetting/internal/jsjson"
+)
+
+type promRange struct{ seconds, step int64 }
+
+// Шаг — чтобы на графике было ~250–360 точек; окно rate — минимум два скрейпа (15 с).
+// Дальше 30 дней не заглядываем: столько Prometheus хранит (promRetention в internal/cli/monitor.go).
+var promRanges = map[string]promRange{
+	"1h": {3600, 15}, "6h": {21600, 60}, "24h": {86400, 300},
+	"7d": {604800, 1800}, "30d": {2592000, 7200},
+}
+
+// Окно rate() — не короче шага: иначе на неделе/месяце точка была бы случайной двухминутной выборкой
+// из двух часов, а не средним за них. Значения «сейчас» при этом считаются отдельно, по окну 2m.
+const promRateWindow = "2m"
+
+func withWindow(q, w string) string { return strings.ReplaceAll(q, "["+promRateWindow+"]", "["+w+"]") }
+
+// rated — ряды, чьё «сейчас» показывает вкладка; при расширенном окне их берём мгновенным запросом.
+var rated = []string{"down", "up", "cpu"}
+
+// Запросы по серверам. Трафик — со счётчиков интерфейса (монотонны), а не с сумм по пирам.
+var promQueries = []struct{ key, q string }{
+	{"down", `sum by (server_id, server) (rate(awg_link_transmit_bytes_total[2m])) * 8`},
+	{"up", `sum by (server_id, server) (rate(awg_link_receive_bytes_total[2m])) * 8`},
+	{"online", `sum by (server_id, server) (awg_peers_online)`},
+	{"heavy", `sum by (server_id, server) (awg_shaping_heavy_devices)`},
+	{"drops", `sum by (server_id, server) (rate(awg_shaping_qdisc_drops_total[2m]))`},
+	{"congested", `max by (server_id, server) (awg_shaping_congested)`},
+	{"scrape_ok", `max by (server_id, server) (awg_scrape_ok)`},
+	{"cpu", `100 * (1 - sum by (server_id, server) (rate(awg_host_cpu_seconds_total{mode=~"idle|iowait"}[2m])) / sum by (server_id, server) (rate(awg_host_cpu_seconds_total[2m])))`},
+	{"mem", `100 * (1 - sum by (server_id, server) (awg_host_memory_available_bytes) / sum by (server_id, server) (awg_host_memory_total_bytes))`},
+	{"cores", `max by (server_id, server) (awg_host_cpu_cores)`},
+	{"mem_total", `max by (server_id, server) (awg_host_memory_total_bytes)`},
+}
+
+type point [2]float64
+
+type seriesOne struct {
+	name   any
+	points []point
+}
+
+// series — server_id → ряд, в порядке ответа Prometheus (как Map в JS).
+type series struct {
+	ids []int
+	m   map[int]*seriesOne
+}
+
+func (s *series) get(id int) *seriesOne {
+	if s == nil {
+		return nil
+	}
+	return s.m[id]
+}
+
+type Monitor struct {
+	a            *App
+	promURL      string
+	localEnabled bool
+	http         *http.Client
+}
+
+func newMonitor(a *App) *Monitor {
+	return &Monitor{
+		a: a, promURL: envOr("PROM_URL", "http://127.0.0.1:9090"),
+		localEnabled: strings.ToLower(envOr("LOCAL_NODE", "on")) != "off",
+		http:         &http.Client{Transport: &http.Transport{Proxy: nil}},
+	}
+}
+
+var errProm = errors.New("Prometheus не отвечает")
+
+func (m *Monitor) rangeQuery(query string, start, end, step int64) (*series, error) {
+	q := url.Values{}
+	q.Set("query", query)
+	q.Set("start", strconv.FormatInt(start, 10))
+	q.Set("end", strconv.FormatInt(end, 10))
+	q.Set("step", strconv.FormatInt(step, 10))
+	c := &http.Client{Transport: m.http.Transport, Timeout: 8 * time.Second}
+	resp, err := c.Get(m.promURL + "/api/v1/query_range?" + q.Encode())
+	if err != nil {
+		return nil, errProm
+	}
+	defer resp.Body.Close()
+	raw, err := io.ReadAll(resp.Body)
+	if err != nil || resp.StatusCode < 200 || resp.StatusCode >= 300 {
+		return nil, errProm
+	}
+	out := &series{m: map[int]*seriesOne{}}
+	for _, r := range arr(field(decodeLikeAxios(raw), "data", "result")) {
+		metric := field(r, "metric")
+		idf := jsToNumberAny(field(metric, "server_id"))
+		if field(metric, "server_id") == nil {
+			idf = math.NaN()
+		}
+		if idf != float64(int(idf)) {
+			continue
+		}
+		id := int(idf)
+		name := field(metric, "server")
+		if name == nil {
+			name = strconv.Itoa(id)
+		}
+		s := &seriesOne{name: name}
+		for _, v := range arr(field(r, "values")) {
+			pair := arr(v)
+			if len(pair) < 2 {
+				continue
+			}
+			t := jsToNumberAny(pair[0])
+			val := jsToNumberAny(pair[1])
+			// NaN/Inf из деления на ноль отбрасываем: на графике это дыра, а не нулевая скорость
+			if math.IsNaN(val) || math.IsInf(val, 0) {
+				continue
+			}
+			s.points = append(s.points, point{t, val})
+		}
+		if _, dup := out.m[id]; !dup {
+			out.ids = append(out.ids, id)
+		}
+		out.m[id] = s
+	}
+	return out, nil
+}
+
+// instantQuery — значение на момент time по каждому server_id.
+func (m *Monitor) instantQuery(query string, time_ int64) (map[int]float64, error) {
+	q := url.Values{}
+	q.Set("query", query)
+	q.Set("time", strconv.FormatInt(time_, 10))
+	c := &http.Client{Transport: m.http.Transport, Timeout: 8 * time.Second}
+	resp, err := c.Get(m.promURL + "/api/v1/query?" + q.Encode())
+	if err != nil {
+		return nil, errProm
+	}
+	defer resp.Body.Close()
+	raw, err := io.ReadAll(resp.Body)
+	if err != nil || resp.StatusCode < 200 || resp.StatusCode >= 300 {
+		return nil, errProm
+	}
+	out := map[int]float64{}
+	for _, r := range arr(field(decodeLikeAxios(raw), "data", "result")) {
+		metric := field(r, "metric")
+		if field(metric, "server_id") == nil {
+			continue
+		}
+		idf := jsToNumberAny(field(metric, "server_id"))
+		pair := arr(field(r, "value"))
+		if idf != float64(int(idf)) || len(pair) < 2 {
+			continue
+		}
+		if v := jsToNumberAny(pair[1]); !math.IsNaN(v) && !math.IsInf(v, 0) {
+			out[int(idf)] = v
+		}
+	}
+	return out, nil
+}
+
+// total — сумма (или максимум) рядов по меткам времени.
+func total(s *series, max bool) []any {
+	acc := map[float64]float64{}
+	var order []float64
+	for _, id := range s.ids {
+		for _, p := range s.m[id].points {
+			cur, seen := acc[p[0]]
+			if !seen {
+				order = append(order, p[0])
+			}
+			if max {
+				acc[p[0]] = math.Max(cur, p[1])
+			} else {
+				acc[p[0]] = cur + p[1]
+			}
+		}
+	}
+	sort.Float64s(order)
+	out := []any{}
+	for _, t := range order {
+		out = append(out, []any{t, acc[t]})
+	}
+	return out
+}
+
+func last(s *seriesOne) any {
+	if s == nil || len(s.points) == 0 {
+		return nil
+	}
+	return s.points[len(s.points)-1][1]
+}
+
+func (m *Monitor) promReady() bool {
+	c := &http.Client{Transport: m.http.Transport, Timeout: 1500 * time.Millisecond}
+	resp, err := c.Get(m.promURL + "/-/ready")
+	if err != nil {
+		return false
+	}
+	resp.Body.Close()
+	return resp.StatusCode == 200
+}
+
+type monitorJob struct {
+	can     bool
+	action  any
+	running bool
+	exit    any
+	log     string
+}
+
+// jobState — установка возможна, только если рядом свой awg-ctrl и он знает маршрут.
+func (m *Monitor) jobState() monitorJob {
+	if !m.localEnabled {
+		return monitorJob{}
+	}
+	r, err := m.a.ctrlLocal("GET", "/api/monitor/job", nil)
+	if err != nil || r.Status != 200 {
+		return monitorJob{}
+	}
+	j := monitorJob{can: true, action: field(r.Data, "action"), running: truthy(field(r.Data, "running")), exit: field(r.Data, "exit")}
+	switch l := field(r.Data, "log").(type) {
+	case nil:
+	case string:
+		j.log = l
+	default:
+		j.log, _ = jsString(l)
+	}
+	return j
+}
+
+func (m *Monitor) router() *Router {
+	rt := newRouter()
+	rt.Get("/", func(c *Ctx) bool {
+		var ready bool
+		var job monitorJob
+		var wg sync.WaitGroup
+		wg.Add(2)
+		go func() { defer wg.Done(); ready = m.promReady() }()
+		go func() { defer wg.Done(); job = m.jobState() }()
+		wg.Wait()
+		var jobOut any
+		if job.can && truthy(job.action) {
+			jobOut = jsjson.Object{{Key: "action", Val: job.action}, {Key: "running", Val: job.running}, {Key: "exit", Val: job.exit}, {Key: "log", Val: job.log}}
+		}
+		return c.JSON(200, jsjson.Object{{Key: "ready", Val: ready}, {Key: "can_install", Val: job.can}, {Key: "job", Val: jobOut},
+			{Key: "command", Val: "awg-ctrl monitor install"}})
+	})
+	// Установка и удаление — одно и то же: просим локальный awg-ctrl, он запускает CLI от root.
+	ask := func(action string) handler {
+		return func(c *Ctx) bool {
+			if !m.localEnabled {
+				return c.Error(409, "У этой панели нет своего VPN-сервера: выполните команду на машине")
+			}
+			r, err := m.a.ctrlLocal("POST", "/api/monitor/"+action, nil)
+			if err != nil {
+				return c.Error(502, "awg-ctrl недоступен")
+			}
+			if r.Status == 404 {
+				return c.Error(501, "awg-ctrl старой версии не умеет этого: обновите сервер или выполните команду вручную")
+			}
+			return c.JSON(r.Status, r.Data)
+		}
+	}
+	rt.Post("/install", ask("install"))
+	rt.Post("/remove", ask("remove"))
+
+	rt.Get("/overview", func(c *Ctx) bool {
+		qs := c.R.URL.Query()
+		rangeKey := "1h"
+		if _, ok := qs["range"]; ok {
+			rangeKey = strings.Join(qs["range"], ",")
+		}
+		rg, ok := promRanges[rangeKey]
+		if !ok {
+			return c.Error(400, "range: 1h, 6h, 24h, 7d или 30d")
+		}
+		end := now()
+		start := end - rg.seconds
+		window := promRateWindow
+		if rg.step > 120 {
+			window = strconv.FormatInt(rg.step, 10) + "s"
+		}
+		got := make([]*series, len(promQueries))
+		errs := make([]error, len(promQueries)+2+len(rated))
+		// Объём за весь период: increase() по тем же монотонным счётчикам (сбросы счётчика он учитывает).
+		// Окно расширено — «сейчас» с конца ряда было бы средним за шаг; берём мгновенные значения по 2m.
+		var usedDown, usedUp map[int]float64
+		nowVals := map[string]map[int]float64{}
+		var mu sync.Mutex
+		var wg sync.WaitGroup
+		for i, pq := range promQueries {
+			wg.Add(1)
+			go func() { defer wg.Done(); got[i], errs[i] = m.rangeQuery(withWindow(pq.q, window), start, end, rg.step) }()
+		}
+		span := strconv.FormatInt(rg.seconds, 10) + "s"
+		n := len(promQueries)
+		wg.Add(2)
+		go func() {
+			defer wg.Done()
+			usedDown, errs[n] = m.instantQuery(`sum by (server_id, server) (increase(awg_link_transmit_bytes_total[`+span+`]))`, end)
+		}()
+		go func() {
+			defer wg.Done()
+			usedUp, errs[n+1] = m.instantQuery(`sum by (server_id, server) (increase(awg_link_receive_bytes_total[`+span+`]))`, end)
+		}()
+		if window != promRateWindow {
+			for j, k := range rated {
+				for _, pq := range promQueries {
+					if pq.key != k {
+						continue
+					}
+					wg.Add(1)
+					go func() {
+						defer wg.Done()
+						v, err := m.instantQuery(pq.q, end)
+						errs[n+2+j] = err
+						mu.Lock()
+						nowVals[k] = v
+						mu.Unlock()
+					}()
+				}
+			}
+		}
+		wg.Wait()
+		for _, err := range errs {
+			if err != nil {
+				return c.Error(502, err.Error())
+			}
+		}
+		used := func(v map[int]float64, id int) any {
+			if x, ok := v[id]; ok {
+				return x
+			}
+			return nil
+		}
+		// Вкладка показывает один сервер — выбранный в сервер-баре (?server=<id>).
+		if _, has := qs["server"]; has {
+			if f := jsToNumber(strings.Join(qs["server"], ",")); f == float64(int(f)) {
+				only := int(f)
+				for i, s := range got {
+					f := &series{m: map[int]*seriesOne{}}
+					if x, ok := s.m[only]; ok {
+						f.ids, f.m[only] = []int{only}, x
+					}
+					got[i] = f
+				}
+			}
+		}
+		s := map[string]*series{}
+		for i, pq := range promQueries {
+			s[pq.key] = got[i]
+		}
+		cur := func(k string, id int) any {
+			if v, ok := nowVals[k]; ok {
+				if x, ok := v[id]; ok {
+					return x
+				}
+				return nil
+			}
+			return last(s[k].get(id))
+		}
+		ids := map[int]bool{}
+		for _, x := range got {
+			for _, id := range x.ids {
+				ids[id] = true
+			}
+		}
+		var sorted []int
+		for id := range ids {
+			sorted = append(sorted, id)
+		}
+		sort.Ints(sorted)
+		servers := []any{}
+		for _, id := range sorted {
+			var name any = strconv.Itoa(id)
+			for _, k := range []string{"scrape_ok", "down", "online"} {
+				if x := s[k].get(id); x != nil {
+					name = x.name
+					break
+				}
+			}
+			servers = append(servers, jsjson.Object{
+				{Key: "id", Val: id}, {Key: "name", Val: name}, {Key: "ok", Val: last(s["scrape_ok"].get(id)) == 1.0},
+				{Key: "down", Val: cur("down", id)}, {Key: "up", Val: cur("up", id)},
+				{Key: "online", Val: last(s["online"].get(id))}, {Key: "heavy", Val: last(s["heavy"].get(id))},
+				{Key: "congested", Val: last(s["congested"].get(id)) == 1.0}, {Key: "cpu", Val: cur("cpu", id)},
+				{Key: "mem", Val: last(s["mem"].get(id))}, {Key: "cores", Val: last(s["cores"].get(id))},
+				{Key: "mem_total", Val: last(s["mem_total"].get(id))},
+				{Key: "used_down", Val: used(usedDown, id)}, {Key: "used_up", Val: used(usedUp, id)},
+			})
+		}
+		var rangeOut any = "1h"
+		if _, ok := qs["range"]; ok {
+			rangeOut = rangeKey
+		}
+		return c.JSON(200, jsjson.Object{
+			{Key: "range", Val: rangeOut}, {Key: "step", Val: rg.step}, {Key: "from", Val: start}, {Key: "to", Val: end},
+			{Key: "servers", Val: servers},
+			{Key: "total", Val: jsjson.Object{
+				{Key: "down", Val: total(s["down"], false)}, {Key: "up", Val: total(s["up"], false)}, {Key: "online", Val: total(s["online"], false)},
+				{Key: "heavy", Val: total(s["heavy"], false)}, {Key: "drops", Val: total(s["drops"], false)},
+				{Key: "cpu", Val: total(s["cpu"], true)}, {Key: "mem", Val: total(s["mem"], true)},
+			}},
+		})
+	})
+	return rt
+}

internal/ui/nodes.go

@@ -0,0 +1,863 @@
+package ui
+
+// Несколько серверов под одной панелью (порт awg-ui/nodes.ts): core (эта панель) и ноды —
+// VPN-серверы, которые сами открывают к core исходящее WSS-соединение (awg-control agent).
+// Реестр нод лежит в ui.db, RPC к ноде идёт по этому соединению, а нода исполняет запрос на
+// своём 127.0.0.1-awg-ctrl. awg-ctrl про ноды ничего не знает.
+//
+// server_id 0 — локальный awg-ctrl этой же машины; при LOCAL_NODE=off его нет, core работает
+// как чистая панель. Протокол и формат join-строки — docs/node-protocol.md.
+
+import (
+	"context"
+	"crypto/ed25519"
+	"crypto/rand"
+	"crypto/sha256"
+	"crypto/subtle"
+	"crypto/tls"
+	"database/sql"
+	"fmt"
+	"net"
+	"net/http"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"regexp"
+	"strconv"
+	"strings"
+	"sync"
+	"time"
+
+	"github.com/coder/websocket"
+
+	"github.com/maeneko/forgetting/internal/jsjson"
+)
+
+const (
+	joinTTL     = 3600 // секунд жизни одноразового секрета
+	authTimeout = 10 * time.Second
+	healthEvery = 15 * time.Second
+	pingEvery   = 20 * time.Second
+	rpcTimeout  = 15 * time.Second
+	rpcSlow     = 120 * time.Second // /awg/*: рестарт и upgrade идут долго
+	hubMaxFrame = 4 * 1024 * 1024
+	failWindow  = 15 * time.Minute
+	failMaxHits = 20
+)
+
+var (
+	reNodeName = regexp.MustCompile(`^[^\r\n<>]+$`) // длину — lenOK: в JS {1,40} считает UTF-16
+	reHost     = regexp.MustCompile(`^[A-Za-z0-9.:_-]{1,253}$`)
+	reVersion  = regexp.MustCompile(`^[\w.+-]{1,32}$`)
+)
+
+// authMsg — сообщение, которое нода подписывает своим ключом. Дублируется в internal/agent.
+func authMsg(nonce string, nodeID int64) []byte {
+	return []byte("awg-node-v1\n" + nonce + "\n" + strconv.FormatInt(nodeID, 10))
+}
+
+type nodeRow struct {
+	ID          int64
+	Name        string
+	Pub         sql.NullString
+	JoinHash    []byte
+	JoinExpires sql.NullInt64
+	CreatedAt   int64
+	LastSeen    sql.NullInt64
+	Version     sql.NullString
+}
+
+const nodeCols = "id, name, pub, join_hash, join_expires, created_at, last_seen, version"
+
+func scanNode(row interface{ Scan(...any) error }) (*nodeRow, error) {
+	n := &nodeRow{}
+	if err := row.Scan(&n.ID, &n.Name, &n.Pub, &n.JoinHash, &n.JoinExpires, &n.CreatedAt, &n.LastSeen, &n.Version); err != nil {
+		return nil, err
+	}
+	return n, nil
+}
+
+// health — сводка /health сервера; ip — как пришло (`d.ip ?? ""`).
+type health struct {
+	Server string
+	IP     any
+	Gen    any
+	Peers  any
+	AwgUp  bool
+	Module any
+	Tools  any
+}
+
+func (h *health) json() any {
+	if h == nil {
+		return nil
+	}
+	return jsjson.Object{{Key: "server", Val: h.Server}, {Key: "ip", Val: h.IP}, {Key: "gen", Val: h.Gen}, {Key: "peers", Val: h.Peers},
+		{Key: "awg_up", Val: h.AwgUp}, {Key: "module", Val: h.Module}, {Key: "tools", Val: h.Tools}}
+}
+
+type pending struct {
+	ch    chan *CtrlResp
+	timer *time.Timer
+}
+
+type nodeConn struct {
+	ws      *websocket.Conn
+	mu      sync.Mutex // seq, pending, alive
+	seq     int64
+	alive   bool
+	pending map[int64]*pending
+	closed  bool
+}
+
+type deleteVeto struct {
+	Error    string
+	Forcible bool
+}
+
+type Nodes struct {
+	a        *App
+	port     int
+	local    bool
+	tls      *tls.Config
+	pin      []byte
+	mu       sync.Mutex
+	conns    map[int64]*nodeConn
+	health   map[int64]*health
+	failHits map[string]*rateEntry
+
+	hmu           sync.Mutex
+	onlineHandler []func(id int)
+	beforeDelete  []func(id int, force bool) *deleteVeto
+	afterDelete   []func(id int)
+}
+
+var offline = &CtrlResp{502, errObj("Сервер недоступен")}
+
+func newNodes(a *App) (*Nodes, error) {
+	n := &Nodes{
+		a: a, port: envNum("NODE_PORT"),
+		local: strings.ToLower(envOr("LOCAL_NODE", "on")) != "off",
+		conns: map[int64]*nodeConn{}, health: map[int64]*health{}, failHits: map[string]*rateEntry{},
+	}
+	file := func(env, name string) string {
+		if v := os.Getenv(env); v != "" {
+			return v
+		}
+		return filepath.Join(a.baseDir, name)
+	}
+	// TLS: самоподписанный сертификат, pin которого зашит в join-строки. Живёт столько же,
+	// сколько core: пересоздать = переподключить все ноды.
+	if n.port != 0 {
+		keyF, crtF := file("NODE_TLS_KEY_FILE", "node_tls.key"), file("NODE_TLS_CERT_FILE", "node_tls.crt")
+		if err := func() error {
+			if !exists(keyF) && !exists(crtF) {
+				cmd := exec.Command("openssl", "req", "-x509", "-newkey", "ec", "-pkeyopt", "ec_paramgen_curve:prime256v1", "-nodes",
+					"-keyout", keyF, "-out", crtF, "-days", "3650", "-subj", "/CN=awg-node")
+				if err := cmd.Run(); err != nil {
+					return err
+				}
+				os.Chmod(keyF, 0o600)
+				os.Chmod(crtF, 0o600)
+				logf("nodes: создан самоподписанный сертификат %s", crtF)
+			}
+			crt, err := os.ReadFile(crtF)
+			if err != nil {
+				return err
+			}
+			cert, err := tls.LoadX509KeyPair(crtF, keyF)
+			if err != nil {
+				return err
+			}
+			pin, err := spkiPin(crt)
+			if err != nil {
+				return err
+			}
+			n.tls = &tls.Config{Certificates: []tls.Certificate{cert}}
+			n.pin = pin
+			return nil
+		}(); err != nil {
+			warnf("nodes: сертификат хаба недоступен (%s) — приём нод отключён", crtF)
+			n.tls, n.pin = nil, nil
+		}
+	}
+
+	if _, err := a.db.Exec(`
+        CREATE TABLE IF NOT EXISTS nodes (
+            id           INTEGER PRIMARY KEY AUTOINCREMENT,
+            name         TEXT    NOT NULL,
+            pub          TEXT,
+            join_hash    BLOB,
+            join_expires INTEGER,
+            created_at   INTEGER NOT NULL,
+            last_seen    INTEGER
+        );
+    `); err != nil {
+		return nil, err
+	}
+	// Версия Forgetting на ноде — из кадра auth (агенты до 0.3.4 её не присылают).
+	if !hasColumn(a.db, "nodes", "version") {
+		if _, err := a.db.Exec("ALTER TABLE nodes ADD COLUMN version TEXT"); err != nil {
+			return nil, err
+		}
+	}
+	return n, nil
+}
+
+func exists(f string) bool {
+	_, err := os.Stat(f)
+	return err == nil
+}
+
+func hasColumn(db queryer, table, col string) bool {
+	rows, err := db.Query("PRAGMA table_info(" + table + ")")
+	if err != nil {
+		return false
+	}
+	defer rows.Close()
+	cols, _ := rows.Columns()
+	vals := make([]any, len(cols))
+	ptrs := make([]any, len(cols))
+	for i := range vals {
+		ptrs[i] = &vals[i]
+	}
+	for rows.Next() {
+		rows.Scan(ptrs...)
+		for i, c := range cols {
+			if c == "name" && fmt.Sprint(vals[i]) == col {
+				return true
+			}
+		}
+	}
+	return false
+}
+
+func (n *Nodes) row(id int64) *nodeRow {
+	r, _ := scanNode(n.a.db.QueryRow("SELECT "+nodeCols+" FROM nodes WHERE id = ?", id))
+	return r
+}
+
+func (n *Nodes) all() []*nodeRow {
+	rows, err := n.a.db.Query("SELECT " + nodeCols + " FROM nodes ORDER BY id")
+	if err != nil {
+		return nil
+	}
+	defer rows.Close()
+	var out []*nodeRow
+	for rows.Next() {
+		if r, err := scanNode(rows); err == nil {
+			out = append(out, r)
+		}
+	}
+	return out
+}
+
+// ── RPC к нодам ─────────────────────────────────────────────────────────────
+
+func (n *Nodes) rpc(id int64, method, path string, body any) *CtrlResp {
+	n.mu.Lock()
+	c := n.conns[id]
+	n.mu.Unlock()
+	if c == nil {
+		return offline
+	}
+	c.mu.Lock()
+	if c.closed {
+		c.mu.Unlock()
+		return offline
+	}
+	c.seq++
+	rid := c.seq
+	p := &pending{ch: make(chan *CtrlResp, 1)}
+	timeout := rpcTimeout
+	if strings.HasPrefix(path, "/awg/") {
+		timeout = rpcSlow
+	}
+	p.timer = time.AfterFunc(timeout, func() {
+		c.mu.Lock()
+		delete(c.pending, rid)
+		c.mu.Unlock()
+		p.ch <- &CtrlResp{504, errObj("Сервер не ответил")}
+	})
+	c.pending[rid] = p
+	c.mu.Unlock()
+
+	msg := jsjson.Object{{Key: "t", Val: "req"}, {Key: "id", Val: rid}, {Key: "method", Val: method}, {Key: "path", Val: path}}
+	if body != nil {
+		msg = append(msg, jsjson.KV{Key: "body", Val: body})
+	}
+	if b, err := jsjson.Marshal(msg); err == nil {
+		go c.ws.Write(context.Background(), websocket.MessageText, b)
+	}
+	return <-p.ch
+}
+
+// CtrlFor — контроллер нужного сервера: 0 — локальный awg-ctrl, остальное — нода по WSS.
+func (n *Nodes) CtrlFor(id int) Ctrl {
+	if id == 0 {
+		if !n.local {
+			return func(string, string, any) (*CtrlResp, error) {
+				return &CtrlResp{404, errObj("Локальный сервер не настроен")}, nil
+			}
+		}
+		return n.a.ctrlLocal
+	}
+	if n.row(int64(id)) == nil {
+		return func(string, string, any) (*CtrlResp, error) {
+			return &CtrlResp{404, errObj("Сервер не найден")}, nil
+		}
+	}
+	return func(m, p string, b any) (*CtrlResp, error) { return n.rpc(int64(id), m, p, b), nil }
+}
+
+func (n *Nodes) Exists(id int) bool {
+	if id == 0 {
+		return n.local
+	}
+	return n.row(int64(id)) != nil
+}
+
+// IsOnline — есть ли сейчас связь (локальный считаем доступным всегда).
+func (n *Nodes) IsOnline(id int) bool {
+	if id == 0 {
+		return n.local
+	}
+	n.mu.Lock()
+	defer n.mu.Unlock()
+	return n.conns[int64(id)] != nil
+}
+
+// IDs — все серверы реестра: локальный (если есть) и ноды.
+func (n *Nodes) IDs() []int {
+	var ids []int
+	if n.local {
+		ids = append(ids, 0)
+	}
+	for _, r := range n.all() {
+		ids = append(ids, int(r.ID))
+	}
+	return ids
+}
+
+// OnOnline — подписчики на «сервер снова на связи» (подписка догоняет пропущенное).
+func (n *Nodes) OnOnline(cb func(id int)) {
+	n.hmu.Lock()
+	n.onlineHandler = append(n.onlineHandler, cb)
+	n.hmu.Unlock()
+}
+
+// BeforeDelete — проверка перед удалением сервера: может запретить (forcible — запрет
+// снимается подтверждением оператора). AfterDelete — уборка ссылок на уже удалённый сервер.
+func (n *Nodes) BeforeDelete(cb func(id int, force bool) *deleteVeto) {
+	n.hmu.Lock()
+	n.beforeDelete = append(n.beforeDelete, cb)
+	n.hmu.Unlock()
+}
+
+func (n *Nodes) AfterDelete(cb func(id int)) {
+	n.hmu.Lock()
+	n.afterDelete = append(n.afterDelete, cb)
+	n.hmu.Unlock()
+}
+
+func (n *Nodes) fireOnline(id int) {
+	n.hmu.Lock()
+	hs := append([]func(int){}, n.onlineHandler...)
+	n.hmu.Unlock()
+	for _, cb := range hs {
+		func() {
+			defer func() { recover() }() // подписчик сам разберётся
+			cb(id)
+		}()
+	}
+}
+
+// DefaultID — сервер по умолчанию: локальный, а без него — первая нода.
+func (n *Nodes) DefaultID() int {
+	if n.local {
+		return 0
+	}
+	if all := n.all(); len(all) > 0 {
+		return int(all[0].ID)
+	}
+	return 0
+}
+
+func (n *Nodes) refreshHealth(id int64) {
+	var r *CtrlResp
+	if id == 0 {
+		r, _ = n.a.ctrlLocal("GET", "/health", nil)
+	} else {
+		r = n.rpc(id, "GET", "/health", nil)
+	}
+	var d any
+	if r != nil {
+		d = r.Data
+	}
+	n.mu.Lock()
+	defer n.mu.Unlock()
+	if server, ok := field(d, "server").(string); ok {
+		or := func(v any, def any) any {
+			if v == nil {
+				return def
+			}
+			return v
+		}
+		n.health[id] = &health{
+			Server: server, IP: or(field(d, "ip"), ""), Gen: or(field(d, "gen"), "2"), Peers: or(field(d, "awg", "peers"), 0.0),
+			AwgUp: field(d, "awg", "status") == "ok", Module: or(field(d, "awg", "module"), ""), Tools: or(field(d, "awg", "tools"), ""),
+		}
+	} else {
+		delete(n.health, id)
+	}
+}
+
+// ── Хаб: приём соединений от нод ────────────────────────────────────────────
+
+func (n *Nodes) failed(ip string) {
+	n.mu.Lock()
+	defer n.mu.Unlock()
+	t := nowFn()
+	e := n.failHits[ip]
+	if e == nil || e.resetAt.Before(t) {
+		n.failHits[ip] = &rateEntry{1, t.Add(failWindow)}
+	} else {
+		e.count++
+	}
+}
+
+func (n *Nodes) blocked(ip string) bool {
+	n.mu.Lock()
+	defer n.mu.Unlock()
+	e := n.failHits[ip]
+	return e != nil && e.resetAt.After(nowFn()) && e.count >= failMaxHits
+}
+
+// dropConn — все ждущие запросы получают «недоступен»; из реестра соединений — только если
+// там всё ещё это соединение.
+func (n *Nodes) dropConn(id int64, c *nodeConn) {
+	c.mu.Lock()
+	c.closed = true
+	ps := c.pending
+	c.pending = map[int64]*pending{}
+	c.mu.Unlock()
+	for _, p := range ps {
+		if p.timer.Stop() {
+			p.ch <- offline
+		}
+	}
+	n.mu.Lock()
+	if n.conns[id] == c {
+		delete(n.conns, id)
+		delete(n.health, id)
+	}
+	n.mu.Unlock()
+}
+
+func closeWS(ws *websocket.Conn, code int, reason string) {
+	go ws.Close(websocket.StatusCode(code), reason)
+}
+
+func (n *Nodes) serveWS(w http.ResponseWriter, r *http.Request) {
+	ip, _, _ := net.SplitHostPort(r.RemoteAddr)
+	ws, err := websocket.Accept(w, r, &websocket.AcceptOptions{InsecureSkipVerify: true, CompressionMode: websocket.CompressionDisabled})
+	if err != nil {
+		return
+	}
+	ws.SetReadLimit(hubMaxFrame)
+	if n.blocked(ip) {
+		ws.Close(4029, "rate_limited")
+		return
+	}
+	nb := make([]byte, 16)
+	rand.Read(nb)
+	nonce := b64url.EncodeToString(nb)
+
+	var conn *nodeConn
+	var nodeID int64
+	authTimer := time.AfterFunc(authTimeout, func() { closeWS(ws, 4001, "auth_timeout") })
+	defer authTimer.Stop()
+	deny := func() { n.failed(ip); closeWS(ws, 4003, "unauthorized") }
+
+	authenticate := func(m jsjson.Object) {
+		sig, sigOK := m.Get2("sig").(string)
+		if m.Get2("t") != "auth" || !isInt(m.Get2("node_id")) || !sigOK {
+			deny()
+			return
+		}
+		row := n.row(int64(m.Get2("node_id").(float64)))
+		if row == nil {
+			deny()
+			return
+		}
+		pubB64 := row.Pub.String
+		joining := !row.Pub.Valid
+		if joining {
+			secret, sOK := field(m, "join", "secret").(string)
+			pub, pOK := field(m, "join", "pub").(string)
+			if row.JoinHash == nil || !row.JoinExpires.Valid || row.JoinExpires.Int64 == 0 || row.JoinExpires.Int64 < now() || !sOK || !pOK {
+				deny()
+				return
+			}
+			h := sha256.Sum256(fromB64url(secret))
+			if len(row.JoinHash) != len(h) || subtle.ConstantTimeCompare(h[:], row.JoinHash) != 1 {
+				deny()
+				return
+			}
+			pubB64 = pub
+		}
+		key := fromB64url(pubB64)
+		if len(key) != ed25519.PublicKeySize || !ed25519.Verify(key, authMsg(nonce, row.ID), fromB64url(sig)) {
+			deny()
+			return
+		}
+		authTimer.Stop()
+		if joining {
+			n.a.db.Exec("UPDATE nodes SET pub = ?, join_hash = NULL, join_expires = NULL WHERE id = ?", pubB64, row.ID)
+		}
+		// Версия — только для показа в панели: не подписана, но и доверия не даёт.
+		var version any
+		if v, ok := m.Get2("version").(string); ok && reVersion.MatchString(v) {
+			version = v
+		}
+		n.a.db.Exec("UPDATE nodes SET last_seen = ?, version = ? WHERE id = ?", now(), version, row.ID)
+
+		conn = &nodeConn{ws: ws, alive: true, pending: map[int64]*pending{}}
+		nodeID = row.ID
+		n.mu.Lock()
+		old := n.conns[row.ID]
+		n.conns[row.ID] = conn
+		n.mu.Unlock()
+		if old != nil {
+			n.dropConn(row.ID, old)
+			closeWS(old.ws, 4000, "replaced")
+		}
+		ws.Write(context.Background(), websocket.MessageText, []byte(`{"t":"ready"}`))
+		first := ""
+		if joining {
+			first = " (первое подключение)"
+		}
+		logf("nodes: «%s» (#%d) подключена%s", row.Name, row.ID, first)
+		go n.refreshHealth(row.ID)
+		go n.fireOnline(int(row.ID))
+	}
+
+	hello, _ := jsjson.Marshal(jsjson.Object{{Key: "t", Val: "hello"}, {Key: "nonce", Val: nonce}})
+	ws.Write(r.Context(), websocket.MessageText, hello)
+
+	ctx := context.Background()
+	for {
+		_, raw, err := ws.Read(ctx)
+		if err != nil {
+			break
+		}
+		v, err := jsjson.Decode(raw)
+		if err != nil {
+			closeWS(ws, 4002, "bad_frame")
+			continue
+		}
+		m, _ := v.(jsjson.Object)
+		if conn == nil {
+			authenticate(m)
+			continue
+		}
+		if m.Get2("t") == "res" && isInt(m.Get2("id")) {
+			rid := int64(m.Get2("id").(float64))
+			conn.mu.Lock()
+			p := conn.pending[rid]
+			delete(conn.pending, rid)
+			conn.mu.Unlock()
+			if p == nil || !p.timer.Stop() {
+				continue
+			}
+			st := jsToNumberAny(m.Get2("status"))
+			status := 502
+			if st == st && st != 0 {
+				status = int(st)
+			}
+			p.ch <- &CtrlResp{status, m.Get2("data")}
+		}
+	}
+	if conn != nil {
+		n.dropConn(nodeID, conn)
+		logf("nodes: #%d отключена", nodeID)
+	}
+}
+
+// Start поднимает хаб (если настроен) и периодические ping/health.
+func (n *Nodes) Start() {
+	if n.local {
+		go n.refreshHealth(0)
+		go n.fireOnline(0)
+	}
+	if n.port == 0 || n.tls == nil {
+		return
+	}
+	mux := http.NewServeMux()
+	mux.HandleFunc("/node/v1", n.serveWS)
+	srv := &http.Server{Addr: fmt.Sprintf(":%d", n.port), Handler: mux, TLSConfig: n.tls, ReadHeaderTimeout: 15 * time.Second,
+		ErrorLog: quietLog()}
+	go func() {
+		ln, err := net.Listen("tcp", srv.Addr)
+		if err != nil {
+			warnf("nodes: хаб не запущен: %v", err)
+			return
+		}
+		logf("nodes: hub on :%d (wss)", n.port)
+		srv.ServeTLS(ln, "", "")
+	}()
+
+	go func() {
+		for range time.Tick(pingEvery) {
+			n.mu.Lock()
+			conns := map[int64]*nodeConn{}
+			for id, c := range n.conns {
+				conns[id] = c
+			}
+			n.mu.Unlock()
+			for id, c := range conns {
+				c.mu.Lock()
+				alive := c.alive
+				c.alive = false
+				c.mu.Unlock()
+				if !alive {
+					c.ws.CloseNow()
+					n.dropConn(id, c)
+					continue
+				}
+				go func() {
+					ctx, cancel := context.WithTimeout(context.Background(), pingEvery)
+					defer cancel()
+					if c.ws.Ping(ctx) == nil {
+						c.mu.Lock()
+						c.alive = true
+						c.mu.Unlock()
+					}
+				}()
+			}
+		}
+	}()
+	go func() {
+		for range time.Tick(healthEvery) {
+			n.mu.Lock()
+			var ids []int64
+			for id := range n.conns {
+				ids = append(ids, id)
+			}
+			n.mu.Unlock()
+			for _, id := range ids {
+				go n.refreshHealth(id)
+			}
+		}
+	}()
+}
+
+// ── Роуты панели (/ui/nodes, за JWT) ────────────────────────────────────────
+
+func (n *Nodes) hubReady() bool { return n.port > 0 && n.tls != nil && n.pin != nil }
+
+func (n *Nodes) joinString(host string, id int64, secret []byte) string {
+	b := jsjson.MustMarshal(jsjson.Object{{Key: "v", Val: 1}, {Key: "h", Val: host}, {Key: "p", Val: n.port},
+		{Key: "pin", Val: b64url.EncodeToString(n.pin)}, {Key: "n", Val: id}, {Key: "s", Val: b64url.EncodeToString(secret)}})
+	return "awgjoin://" + b64url.EncodeToString(b)
+}
+
+var rePortSuffix = regexp.MustCompile(`:\d+$`)
+
+func (n *Nodes) hostOf(c *Ctx) string {
+	if given, ok := c.Obj().Get2("host").(string); ok && reHost.MatchString(given) {
+		return given
+	}
+	h := rePortSuffix.ReplaceAllString(c.R.Host, "")
+	return strings.TrimSuffix(strings.TrimPrefix(h, "["), "]")
+}
+
+func nullStr(s sql.NullString) any {
+	if s.Valid {
+		return s.String
+	}
+	return nil
+}
+
+func orNil(s string) any {
+	if s == "" {
+		return nil
+	}
+	return s
+}
+
+// List — серверы со всем, что известно без запросов (health — из кэша). Общий вид для GET / и метрик.
+func (n *Nodes) List() []serverInfo {
+	var out []serverInfo
+	n.mu.Lock()
+	hs := map[int64]*health{}
+	for k, v := range n.health {
+		hs[k] = v
+	}
+	online := map[int64]bool{}
+	for k := range n.conns {
+		online[k] = true
+	}
+	n.mu.Unlock()
+	if n.local {
+		h := hs[0]
+		name := "VPN"
+		if h != nil {
+			name = h.Server
+		}
+		out = append(out, serverInfo{ID: 0, Name: name, Local: true, Online: h != nil, Version: orNil(n.a.version), Health: h})
+	}
+	for _, r := range n.all() {
+		out = append(out, serverInfo{ID: int(r.ID), Name: r.Name, Online: online[r.ID], Pending: !r.Pub.Valid,
+			LastSeen: nullInt(r.LastSeen), Version: nullStr(r.Version), Health: hs[r.ID]})
+	}
+	return out
+}
+
+type serverInfo struct {
+	ID       int
+	Name     string
+	Local    bool
+	Online   bool
+	Pending  bool
+	LastSeen any
+	Version  any
+	Health   *health
+}
+
+func (s serverInfo) json() jsjson.Object {
+	return jsjson.Object{{Key: "id", Val: s.ID}, {Key: "name", Val: s.Name}, {Key: "local", Val: s.Local}, {Key: "online", Val: s.Online},
+		{Key: "pending", Val: s.Pending}, {Key: "last_seen", Val: s.LastSeen}, {Key: "version", Val: s.Version}, {Key: "health", Val: s.Health.json()}}
+}
+
+func (n *Nodes) idOf(c *Ctx) (int64, bool) {
+	f := jsToNumber(c.Params["id"])
+	return int64(f), f == float64(int64(f)) && f >= 1
+}
+
+func (n *Nodes) router() *Router {
+	rt := newRouter()
+	rt.Get("/", func(c *Ctx) bool {
+		if n.local {
+			n.refreshHealth(0)
+		}
+		list := []any{}
+		for _, s := range n.List() {
+			list = append(list, s.json())
+		}
+		return c.JSON(200, jsjson.Object{{Key: "hub", Val: n.hubReady()}, {Key: "local", Val: n.local},
+			{Key: "version", Val: orNil(n.a.version)}, {Key: "nodes", Val: list}})
+	})
+	rt.Post("/", func(c *Ctx) bool {
+		if !n.hubReady() {
+			return c.Error(503, "Приём нод не настроен (NODE_PORT / сертификат)")
+		}
+		name, ok := c.Obj().Get2("name").(string)
+		if !ok || !reNodeName.MatchString(name) || !lenOK(name, 1, 40) {
+			return c.Error(400, "Имя: до 40 символов, без переводов строк и <>")
+		}
+		host := n.hostOf(c)
+		if !reHost.MatchString(host) {
+			return c.Error(400, "Не удалось определить адрес core")
+		}
+		secret := make([]byte, 16)
+		rand.Read(secret)
+		h := sha256.Sum256(secret)
+		res, err := n.a.db.Exec("INSERT INTO nodes (name, join_hash, join_expires, created_at) VALUES (?, ?, ?, ?)", name, h[:], now()+joinTTL, now())
+		if err != nil {
+			return c.Error(500, "Internal server error")
+		}
+		id, _ := res.LastInsertId()
+		return c.JSON(201, jsjson.Object{{Key: "id", Val: id}, {Key: "name", Val: name}, {Key: "join", Val: n.joinString(host, id, secret)}, {Key: "expires_in", Val: joinTTL}})
+	})
+	// Новая join-строка для ноды, которая ещё не подключалась (истёк срок / потеряли).
+	rt.Post("/:id/join", func(c *Ctx) bool {
+		if !n.hubReady() {
+			return c.Error(503, "Приём нод не настроен (NODE_PORT / сертификат)")
+		}
+		id, ok := n.idOf(c)
+		var row *nodeRow
+		if ok {
+			row = n.row(id)
+		}
+		if row == nil {
+			return c.Error(404, "Не найден")
+		}
+		if row.Pub.Valid {
+			return c.Error(409, "Нода уже подключена")
+		}
+		host := n.hostOf(c)
+		if !reHost.MatchString(host) {
+			return c.Error(400, "Не удалось определить адрес core")
+		}
+		secret := make([]byte, 16)
+		rand.Read(secret)
+		h := sha256.Sum256(secret)
+		n.a.db.Exec("UPDATE nodes SET join_hash = ?, join_expires = ? WHERE id = ? AND pub IS NULL", h[:], now()+joinTTL, id)
+		return c.JSON(200, jsjson.Object{{Key: "id", Val: id}, {Key: "name", Val: row.Name}, {Key: "join", Val: n.joinString(host, id, secret)}, {Key: "expires_in", Val: joinTTL}})
+	})
+	rt.Patch("/:id", func(c *Ctx) bool {
+		id, ok := n.idOf(c)
+		if !ok || n.row(id) == nil {
+			return c.Error(404, "Не найден")
+		}
+		name, ok := c.Obj().Get2("name").(string)
+		if !ok || !reNodeName.MatchString(name) || !lenOK(name, 1, 40) {
+			return c.Error(400, "Неверное имя")
+		}
+		n.a.db.Exec("UPDATE nodes SET name = ? WHERE id = ?", name, id)
+		return c.JSON(200, jsjson.Object{{Key: "id", Val: id}, {Key: "name", Val: name}})
+	})
+	rt.Delete("/:id", func(c *Ctx) bool {
+		id, ok := n.idOf(c)
+		if !ok || n.row(id) == nil {
+			return c.Error(404, "Не найден")
+		}
+		// Ключи API и мастер-ключи проверяют их владельцы (BeforeDelete).
+		force := c.R.URL.Query().Get("force") == "1"
+		n.hmu.Lock()
+		before := append([]func(int, bool) *deleteVeto{}, n.beforeDelete...)
+		after := append([]func(int){}, n.afterDelete...)
+		n.hmu.Unlock()
+		for _, cb := range before {
+			veto := func() (v *deleteVeto) {
+				defer func() {
+					if recover() != nil {
+						v = &deleteVeto{"Не удалось подготовить сервер к удалению", true}
+					}
+				}()
+				return cb(int(id), force)
+			}()
+			if veto != nil {
+				return c.JSON(409, jsjson.Object{{Key: "error", Val: veto.Error}, {Key: "can_force", Val: veto.Forcible && !force}})
+			}
+		}
+		if n.row(id) == nil {
+			return c.Error(404, "Не найден")
+		}
+		n.mu.Lock()
+		conn := n.conns[id]
+		n.mu.Unlock()
+		if conn != nil {
+			n.dropConn(id, conn)
+			closeWS(conn.ws, 4004, "removed")
+		}
+		n.a.db.Exec("DELETE FROM nodes WHERE id = ?", id)
+		// Хвосты подписки для этого сервера больше некому доделать.
+		for _, t := range []string{"peer_tombstones", "server_profiles"} {
+			n.a.db.Exec("DELETE FROM "+t+" WHERE server_id = ?", id)
+		}
+		for _, cb := range after {
+			func() {
+				defer func() {
+					if p := recover(); p != nil {
+						warnf("nodes: уборка после удаления #%d: %v", id, p)
+					}
+				}()
+				cb(int(id))
+			}()
+		}
+		return c.JSON(200, jsjson.Object{{Key: "success", Val: true}, {Key: "id", Val: id}})
+	})
+	return rt
+}

internal/ui/sen.go

@@ -0,0 +1,430 @@
+package ui
+
+// sen:// — ссылка-подписка для SenAWG и подписи протокола /sub/v1 (порт awg-ui/sen.ts).
+// Байтовая раскладка и схема подписей описаны в docs/sen-link.md; клиент реализуется по
+// ней, поэтому любое изменение здесь — изменение протокола.
+
+import (
+	"bytes"
+	"crypto/ed25519"
+	"crypto/sha256"
+	"crypto/x509"
+	"encoding/base64"
+	"encoding/binary"
+	"encoding/hex"
+	"encoding/pem"
+	"errors"
+	"fmt"
+	"hash/crc32"
+	"regexp"
+	"strconv"
+	"strings"
+	"unicode/utf8"
+
+	"github.com/maeneko/forgetting/internal/jsjson"
+)
+
+const (
+	senPrefix  = "sen://"
+	senVersion = 1
+	flagTLS    = 0x01
+
+	addrV4     = 0x04
+	addrV6     = 0x06
+	addrDomain = 0x44
+)
+
+type senLinkError struct{ msg string }
+
+func (e *senLinkError) Error() string { return e.msg }
+
+func senErr(f string, a ...any) error { return &senLinkError{fmt.Sprintf(f, a...)} }
+
+type SenAddr struct {
+	Host string `json:"host"`
+	Port int    `json:"port"`
+}
+
+type SenLink struct {
+	TLS     bool
+	Addrs   []SenAddr
+	Secret  []byte // 16 байт
+	SignPub []byte // 32 байта, Ed25519
+	TLSPin  []byte // 32 байта, только при TLS
+	Name    string
+}
+
+// b64url — Buffer.toString("base64url"): без паддинга.
+var b64url = base64.RawURLEncoding
+
+// fromB64url повторяет Buffer.from(s, "base64url") в Node: терпит паддинг и «+/», хвостовой
+// одиночный символ (неполный байт) молча отбрасывает, мусор после первого чужого символа — тоже.
+func fromB64url(s string) []byte {
+	s = strings.NewReplacer("+", "-", "/", "_").Replace(s)
+	if i := strings.IndexFunc(s, func(r rune) bool {
+		return !(r >= 'A' && r <= 'Z' || r >= 'a' && r <= 'z' || r >= '0' && r <= '9' || r == '-' || r == '_')
+	}); i >= 0 {
+		s = s[:i]
+	}
+	if len(s)%4 == 1 {
+		s = s[:len(s)-1]
+	}
+	b, _ := b64url.DecodeString(s)
+	return b
+}
+
+// fromB64 — Buffer.from(s, "base64") (обычный алфавит, тоже нестрого).
+func fromB64(s string) []byte {
+	return fromB64url(strings.TrimRight(s, "="))
+}
+
+// ── Адреса ─────────────────────────────────────────────────────────────────
+
+var (
+	reHex4   = regexp.MustCompile(`^[0-9a-fA-F]{1,4}$`)
+	reIPv4   = regexp.MustCompile(`^\d{1,3}(\.\d{1,3}){3}$`)
+	reDomain = regexp.MustCompile(`^[A-Za-z0-9.-]+$`)
+)
+
+func ipv6ToBytes(host string) []byte {
+	parts := strings.Split(host, "::")
+	if len(parts) > 2 {
+		return nil
+	}
+	var head, tail []string
+	if parts[0] != "" {
+		head = strings.Split(parts[0], ":")
+	}
+	if len(parts) == 2 && parts[1] != "" {
+		tail = strings.Split(parts[1], ":")
+	}
+	missing := 8 - len(head) - len(tail)
+	if len(parts) == 1 && len(head) != 8 || len(parts) == 2 && missing < 1 {
+		return nil
+	}
+	groups := append([]string{}, head...)
+	if len(parts) == 2 {
+		for range missing {
+			groups = append(groups, "0")
+		}
+	}
+	groups = append(groups, tail...)
+	if len(groups) != 8 {
+		return nil
+	}
+	out := make([]byte, 16)
+	for i, g := range groups {
+		if !reHex4.MatchString(g) {
+			return nil
+		}
+		n, _ := strconv.ParseUint(g, 16, 16)
+		binary.BigEndian.PutUint16(out[i*2:], uint16(n))
+	}
+	return out
+}
+
+func bytesToIPv6(b []byte) string {
+	g := make([]string, 8)
+	for i := range 8 {
+		g[i] = strconv.FormatUint(uint64(binary.BigEndian.Uint16(b[i*2:])), 16)
+	}
+	// Самый длинный run нулей сворачиваем в «::» — как принято в текстовой записи.
+	bestStart, bestLen := -1, 0
+	for i := 0; i < 8; {
+		if g[i] != "0" {
+			i++
+			continue
+		}
+		j := i
+		for j < 8 && g[j] == "0" {
+			j++
+		}
+		if j-i > bestLen {
+			bestStart, bestLen = i, j-i
+		}
+		i = j
+	}
+	if bestLen < 2 {
+		return strings.Join(g, ":")
+	}
+	return strings.Join(g[:bestStart], ":") + "::" + strings.Join(g[bestStart+bestLen:], ":")
+}
+
+func encodeAddr(a SenAddr) ([]byte, error) {
+	if a.Port < 1 || a.Port > 65535 {
+		return nil, senErr("Неверный порт: %d", a.Port)
+	}
+	p := binary.BigEndian.AppendUint16(nil, uint16(a.Port))
+	if reIPv4.MatchString(a.Host) {
+		out := []byte{addrV4}
+		for _, o := range strings.Split(a.Host, ".") {
+			n, _ := strconv.Atoi(o)
+			if n > 255 {
+				return nil, senErr("Неверный IPv4: %s", a.Host)
+			}
+			out = append(out, byte(n))
+		}
+		return append(out, p...), nil
+	}
+	if strings.Contains(a.Host, ":") {
+		b := ipv6ToBytes(a.Host)
+		if b == nil {
+			return nil, senErr("Неверный IPv6: %s", a.Host)
+		}
+		return append(append([]byte{addrV6}, b...), p...), nil
+	}
+	if len(a.Host) < 1 || len(a.Host) > 253 || !reDomain.MatchString(a.Host) {
+		return nil, senErr("Неверный домен: %s", a.Host)
+	}
+	return append(append([]byte{addrDomain, byte(len(a.Host))}, a.Host...), p...), nil
+}
+
+// ── Ссылка ─────────────────────────────────────────────────────────────────
+
+func EncodeSenLink(l SenLink) (string, error) {
+	if len(l.Addrs) < 1 || len(l.Addrs) > 3 {
+		return "", senErr("Адресов должно быть от 1 до 3")
+	}
+	if len(l.Secret) != 16 {
+		return "", senErr("secret: 16 байт")
+	}
+	if len(l.SignPub) != 32 {
+		return "", senErr("signPub: 32 байта")
+	}
+	if l.TLS && len(l.TLSPin) != 32 {
+		return "", senErr("tlsPin: 32 байта при TLS")
+	}
+	if len(l.Name) > 64 {
+		return "", senErr("Имя: до 64 байт")
+	}
+	var flags byte
+	if l.TLS {
+		flags = flagTLS
+	}
+	body := []byte{senVersion, flags, byte(len(l.Addrs))}
+	for _, a := range l.Addrs {
+		b, err := encodeAddr(a)
+		if err != nil {
+			return "", err
+		}
+		body = append(body, b...)
+	}
+	body = append(body, l.Secret...)
+	body = append(body, l.SignPub...)
+	if l.TLS {
+		body = append(body, l.TLSPin...)
+	}
+	body = append(body, byte(len(l.Name)))
+	body = append(body, l.Name...)
+	body = binary.BigEndian.AppendUint32(body, crc32.ChecksumIEEE(body))
+	return senPrefix + b64url.EncodeToString(body), nil
+}
+
+var (
+	reB64urlChars = regexp.MustCompile(`^[A-Za-z0-9_-]+$`)
+	reSpaces      = regexp.MustCompile(`\s+`)
+)
+
+func DecodeSenLink(link string) (SenLink, error) {
+	var l SenLink
+	t := strings.TrimSpace(link)
+	if !strings.HasPrefix(strings.ToLower(t), senPrefix) {
+		return l, senErr("Ссылка должна начинаться с sen://")
+	}
+	payload := reSpaces.ReplaceAllString(t[len(senPrefix):], "")
+	if !reB64urlChars.MatchString(payload) {
+		return l, senErr("Ссылка повреждена: недопустимые символы")
+	}
+	raw := fromB64url(payload)
+	if len(raw) < 3+4 {
+		return l, senErr("Ссылка слишком короткая")
+	}
+	body := raw[:len(raw)-4]
+	if binary.BigEndian.Uint32(raw[len(raw)-4:]) != crc32.ChecksumIEEE(body) {
+		return l, senErr("Ссылка повреждена: не сошлась контрольная сумма")
+	}
+
+	off := 0
+	errCut := senErr("Ссылка обрезана")
+	take := func(n int) ([]byte, error) {
+		if off+n > len(body) {
+			return nil, errCut
+		}
+		s := body[off : off+n]
+		off += n
+		return s, nil
+	}
+	b1 := func() (byte, error) {
+		b, err := take(1)
+		if err != nil {
+			return 0, err
+		}
+		return b[0], nil
+	}
+
+	version, err := b1()
+	if err != nil {
+		return l, err
+	}
+	if version != senVersion {
+		return l, senErr("Неизвестная версия ссылки: %d", version)
+	}
+	flags, err := b1()
+	if err != nil {
+		return l, err
+	}
+	if flags&^flagTLS != 0 {
+		return l, senErr("Неизвестные флаги ссылки")
+	}
+	n, err := b1()
+	if err != nil {
+		return l, err
+	}
+	if n < 1 || n > 3 {
+		return l, senErr("Неверное число адресов")
+	}
+	for range n {
+		typ, err := b1()
+		if err != nil {
+			return l, err
+		}
+		var host string
+		switch typ {
+		case addrV4:
+			b, err := take(4)
+			if err != nil {
+				return l, err
+			}
+			host = fmt.Sprintf("%d.%d.%d.%d", b[0], b[1], b[2], b[3])
+		case addrV6:
+			b, err := take(16)
+			if err != nil {
+				return l, err
+			}
+			host = bytesToIPv6(b)
+		case addrDomain:
+			ln, err := b1()
+			if err != nil {
+				return l, err
+			}
+			if ln < 1 {
+				return l, senErr("Пустой домен")
+			}
+			b, err := take(int(ln))
+			if err != nil {
+				return l, err
+			}
+			host = jsUTF8(b)
+			if !reDomain.MatchString(host) {
+				return l, senErr("Неверный домен")
+			}
+		default:
+			return l, senErr("Неизвестный тип адреса: %d", typ)
+		}
+		pb, err := take(2)
+		if err != nil {
+			return l, err
+		}
+		port := int(binary.BigEndian.Uint16(pb))
+		if port == 0 {
+			return l, senErr("Порт 0")
+		}
+		l.Addrs = append(l.Addrs, SenAddr{host, port})
+	}
+	if l.Secret, err = take(16); err != nil {
+		return l, err
+	}
+	if l.SignPub, err = take(32); err != nil {
+		return l, err
+	}
+	l.TLS = flags&flagTLS != 0
+	if l.TLS {
+		if l.TLSPin, err = take(32); err != nil {
+			return l, err
+		}
+	}
+	nameLen, err := b1()
+	if err != nil {
+		return l, err
+	}
+	if nameLen > 64 {
+		return l, senErr("Имя длиннее 64 байт")
+	}
+	nb, err := take(int(nameLen))
+	if err != nil {
+		return l, err
+	}
+	l.Name = jsUTF8(nb)
+	if off != len(body) {
+		return l, senErr("Лишние данные в конце ссылки")
+	}
+	l.Secret, l.SignPub = bytes.Clone(l.Secret), bytes.Clone(l.SignPub)
+	l.TLSPin = bytes.Clone(l.TLSPin)
+	return l, nil
+}
+
+// jsUTF8 — Buffer.toString("utf8"): битые последовательности заменяются на U+FFFD.
+func jsUTF8(b []byte) string {
+	if utf8.Valid(b) {
+		return string(b)
+	}
+	return strings.ToValidUTF8(string(b), "�")
+}
+
+// ── Ключи Ed25519 ──────────────────────────────────────────────────────────
+
+// loadEd25519Private читает PKCS#8 PEM (как crypto.createPrivateKey в Node).
+func loadEd25519Private(raw []byte) (ed25519.PrivateKey, error) {
+	blk, _ := pem.Decode(raw)
+	if blk == nil {
+		return nil, errors.New("not a PEM key")
+	}
+	k, err := x509.ParsePKCS8PrivateKey(blk.Bytes)
+	if err != nil {
+		return nil, err
+	}
+	priv, ok := k.(ed25519.PrivateKey)
+	if !ok {
+		return nil, errors.New("not an Ed25519 key")
+	}
+	return priv, nil
+}
+
+// spkiPin — SHA-256 от SPKI DER сертификата (первого в PEM) — то, что кладётся в ссылку как pin.
+func spkiPin(certPEM []byte) ([]byte, error) {
+	blk, _ := pem.Decode(certPEM)
+	if blk == nil {
+		return nil, errors.New("not a PEM certificate")
+	}
+	c, err := x509.ParseCertificate(blk.Bytes)
+	if err != nil {
+		return nil, err
+	}
+	sum := sha256.Sum256(c.RawSubjectPublicKeyInfo)
+	return sum[:], nil
+}
+
+// ── Подписи протокола ──────────────────────────────────────────────────────
+
+// signedResponse — {"body": "<JSON-строка>", "sig": "<base64url>"}; sig — Ed25519 над
+// UTF-8 байтами строки body. body — именно строка, чтобы клиенту не нужна была
+// каноническая сериализация JSON.
+func signResponse(payload any, key ed25519.PrivateKey) jsjson.Object {
+	body := string(jsjson.MustMarshal(payload))
+	return jsjson.Object{{Key: "body", Val: body}, {Key: "sig", Val: b64url.EncodeToString(ed25519.Sign(key, []byte(body)))}}
+}
+
+// requestSigString — METHOD \n /path \n ts \n hex(sha256(тело запроса)); path — без query.
+func requestSigString(method, path string, ts int64, body []byte) string {
+	h := sha256.Sum256(body)
+	return strings.ToUpper(method) + "\n" + path + "\n" + strconv.FormatInt(ts, 10) + "\n" + hex.EncodeToString(h[:])
+}
+
+func verifyRequest(method, path string, ts int64, body []byte, sig string, authPub []byte) bool {
+	if len(authPub) != ed25519.PublicKeySize {
+		return false
+	}
+	return ed25519.Verify(authPub, []byte(requestSigString(method, path, ts, body)), fromB64url(sig))
+}
+
+func crc32IEEE(b []byte) uint32 { return crc32.ChecksumIEEE(b) }

internal/ui/sen_test.go

@@ -0,0 +1,142 @@
+package ui
+
+import (
+	"crypto/ed25519"
+	"encoding/hex"
+	"encoding/json"
+	"os"
+	"testing"
+
+	"github.com/maeneko/forgetting/internal/jsjson"
+)
+
+// Эталон — вывод самого awg-ui/sen.ts (tools/golden/sen.ts).
+type senFixture struct {
+	SignSeed string `json:"sign_seed"`
+	SignPub  string `json:"sign_pub"`
+	CRC32    []struct {
+		In  string `json:"in"`
+		Out uint32 `json:"out"`
+	} `json:"crc32"`
+	Encode []struct {
+		TLS    bool      `json:"tls"`
+		Addrs  []SenAddr `json:"addrs"`
+		Secret string    `json:"secret"`
+		TLSPin string    `json:"tlsPin"`
+		Name   string    `json:"name"`
+		Out    string    `json:"out"`
+		Error  string    `json:"error"`
+	} `json:"encode"`
+	EncodeErrors []struct {
+		TLS    bool      `json:"tls"`
+		Addrs  []SenAddr `json:"addrs"`
+		Secret string    `json:"secret"`
+		Name   string    `json:"name"`
+		Error  string    `json:"error"`
+	} `json:"encode_errors"`
+	Decode []struct {
+		In      string    `json:"in"`
+		Error   string    `json:"error"`
+		TLS     bool      `json:"tls"`
+		Addrs   []SenAddr `json:"addrs"`
+		Secret  string    `json:"secret"`
+		SignPub string    `json:"signPub"`
+		TLSPin  *string   `json:"tlsPin"`
+		Name    string    `json:"name"`
+	} `json:"decode"`
+	SigString []struct {
+		Method, Path, Body, Out, Sig string
+		TS                           int64 `json:"ts"`
+	} `json:"sig_string"`
+	SignResponse []struct {
+		In  json.RawMessage `json:"in"`
+		Out struct{ Body, Sig string }
+	} `json:"sign_response"`
+}
+
+func unhex(t *testing.T, s string) []byte {
+	b, err := hex.DecodeString(s)
+	if err != nil {
+		t.Fatal(err)
+	}
+	return b
+}
+
+func TestSenAgainstNode(t *testing.T) {
+	raw, err := os.ReadFile("../../testdata/golden/sen.json")
+	if err != nil {
+		t.Fatal(err)
+	}
+	var f senFixture
+	if err := json.Unmarshal(raw, &f); err != nil {
+		t.Fatal(err)
+	}
+	key := ed25519.NewKeyFromSeed(unhex(t, f.SignSeed))
+	signPub := key.Public().(ed25519.PublicKey)
+	if hex.EncodeToString(signPub) != f.SignPub {
+		t.Fatal("sign key mismatch")
+	}
+
+	for _, c := range f.CRC32 {
+		if got := crc32IEEE([]byte(c.In)); got != c.Out {
+			t.Errorf("crc32(%q) = %d, want %d", c.In, got, c.Out)
+		}
+	}
+	for _, c := range f.Encode {
+		l := SenLink{TLS: c.TLS, Addrs: c.Addrs, Secret: unhex(t, c.Secret), SignPub: signPub, Name: c.Name}
+		if c.TLSPin != "" {
+			l.TLSPin = unhex(t, c.TLSPin)
+		}
+		got, err := EncodeSenLink(l)
+		if err != nil || got != c.Out {
+			t.Errorf("encode %+v:\n got %s %v\nwant %s", c.Addrs, got, err, c.Out)
+		}
+	}
+	for _, c := range f.EncodeErrors {
+		_, err := EncodeSenLink(SenLink{TLS: c.TLS, Addrs: c.Addrs, Secret: unhex(t, c.Secret), SignPub: signPub, Name: c.Name})
+		if err == nil || err.Error() != c.Error {
+			t.Errorf("encode error %+v: got %v, want %s", c.Addrs, err, c.Error)
+		}
+	}
+	for _, c := range f.Decode {
+		l, err := DecodeSenLink(c.In)
+		if c.Error != "" {
+			if err == nil || err.Error() != c.Error {
+				t.Errorf("decode %q: got %v, want error %s", c.In, err, c.Error)
+			}
+			continue
+		}
+		if err != nil {
+			t.Errorf("decode %q: %v", c.In, err)
+			continue
+		}
+		gotAddrs, _ := json.Marshal(l.Addrs)
+		wantAddrs, _ := json.Marshal(c.Addrs)
+		pin := ""
+		if c.TLSPin != nil {
+			pin = *c.TLSPin
+		}
+		if l.TLS != c.TLS || string(gotAddrs) != string(wantAddrs) || hex.EncodeToString(l.Secret) != c.Secret ||
+			hex.EncodeToString(l.SignPub) != c.SignPub || hex.EncodeToString(l.TLSPin) != pin || l.Name != c.Name {
+			t.Errorf("decode %q:\n got %+v %s", c.In, l, gotAddrs)
+		}
+	}
+	for _, c := range f.SigString {
+		if got := requestSigString(c.Method, c.Path, c.TS, []byte(c.Body)); got != c.Out {
+			t.Errorf("sig string: got %q want %q", got, c.Out)
+		}
+		if !verifyRequest(c.Method, c.Path, c.TS, []byte(c.Body), c.Sig, signPub) {
+			t.Errorf("Node signature for %s %s does not verify", c.Method, c.Path)
+		}
+		if verifyRequest(c.Method, c.Path, c.TS+1, []byte(c.Body), c.Sig, signPub) {
+			t.Error("signature verifies for another ts")
+		}
+	}
+	for _, c := range f.SignResponse {
+		v, _ := jsjson.Decode(c.In)
+		got := signResponse(v, key)
+		if got.Get2("body") != c.Out.Body || got.Get2("sig") != c.Out.Sig {
+			t.Errorf("signResponse: got %v want %+v", got, c.Out)
+		}
+	}
+}

internal/ui/server.go

@@ -0,0 +1,949 @@
+// Package ui — awg-ui на Go (порт awg-ui/server.ts и модулей): веб-панель с JWT, прокси к
+// awg-ctrl, публичный API /api/v1 по ключам, хаб нод (WSS), подписка sen:// и /metrics.
+// Фронтенд тот же (React, собранный в dist/) — сервер его только раздаёт.
+package ui
+
+import (
+	"crypto/ed25519"
+	"crypto/hmac"
+	"crypto/rand"
+	"crypto/sha256"
+	"database/sql"
+	"encoding/hex"
+	"fmt"
+	"net"
+	"net/http"
+	"net/url"
+	"os"
+	"path/filepath"
+	"regexp"
+	"sort"
+	"strconv"
+	"strings"
+	"sync"
+	"time"
+
+	_ "modernc.org/sqlite"
+
+	"github.com/maeneko/forgetting/internal/iauth"
+	"github.com/maeneko/forgetting/internal/jsjson"
+)
+
+// ── Журнал: как console.log / console.warn у Node-версии (CLI пишет оба потока в один файл) ──
+
+func logf(f string, a ...any)  { fmt.Fprintf(os.Stdout, f+"\n", a...) }
+func warnf(f string, a ...any) { fmt.Fprintf(os.Stderr, f+"\n", a...) }
+
+var nowFn = time.Now
+
+func now() int64 { return nowFn().Unix() }
+
+func envOr(key, def string) string {
+	if v, ok := os.LookupEnv(key); ok {
+		return v
+	}
+	return def
+}
+
+// envNum — Number(process.env.X) || 0.
+func envNum(key string) int {
+	f := jsToNumber(os.Getenv(key))
+	if f != f || f == 0 || f != float64(int(f)) {
+		return 0
+	}
+	return int(f)
+}
+
+// envFromFile — значение KEY=… из .env (первая строка, обрезанная).
+func envFromFile(file, key string) string {
+	raw, err := os.ReadFile(file)
+	if err != nil {
+		return ""
+	}
+	m := regexp.MustCompile(`(?m)^\s*` + regexp.QuoteMeta(key) + `\s*=\s*(.*)$`).FindSubmatch(raw)
+	if m == nil {
+		return ""
+	}
+	return strings.TrimSpace(string(m[1]))
+}
+
+// ── Клиент awg-ctrl ─────────────────────────────────────────────────────────
+
+type CtrlResp struct {
+	Status int
+	Data   any // разобранный JSON, иначе строка (как axios)
+}
+
+// Ctrl — запрос к awg-ctrl сервера: локальному по HTTP или к ноде по WSS. Ошибка — только
+// когда ответа нет вовсе (сеть, нет ключа); статусы ≥ 400 приходят как есть.
+type Ctrl func(method, path string, body any) (*CtrlResp, error)
+
+// decodeLikeAxios — тело ответа так, как его отдал бы axios: JSON — значением, иначе строкой.
+func decodeLikeAxios(raw []byte) any {
+	if len(raw) == 0 {
+		return ""
+	}
+	if v, err := jsjson.Decode(raw); err == nil {
+		return v
+	}
+	return string(raw)
+}
+
+type App struct {
+	port      int
+	uiUser    string
+	uiPass    string
+	jwtSecret []byte
+	brand     string
+	channel   string
+	version   string
+	ctrlURL   string
+	baseDir   string
+
+	internalKey ed25519.PrivateKey
+	httpLocal   *http.Client
+
+	db *sql.DB
+
+	mu            sync.Mutex
+	revoked       map[string]bool
+	loginAttempts map[string]*rateEntry
+
+	nodes   *Nodes
+	sub     *Sub
+	metrics *Metrics
+	monitor *Monitor
+}
+
+// New готовит панель: база, ключи, модули. Каталог панели — рабочий каталог процесса
+// (CLI запускает сервис с cwd = <root>/awg-ui): там dist/, panel.id и ключи по умолчанию.
+func New() (*App, error) {
+	cwd, _ := os.Getwd()
+	rootEnv := filepath.Join(cwd, "..", ".env")
+	pick := func(key, def string) string {
+		if v := os.Getenv(key); v != "" {
+			return v
+		}
+		if v := envFromFile(rootEnv, key); v != "" {
+			return v
+		}
+		return def
+	}
+	a := &App{
+		port:    envNum("PORT"),
+		uiUser:  envOr("UI_USER", "admin"),
+		uiPass:  os.Getenv("UI_PASS"),
+		brand:   pick("BRAND", "Forgetting"),
+		channel: pick("CHANNEL", "Beta"),
+		version: pick("VERSION", ""),
+		ctrlURL: "http://127.0.0.1:" + envOr("AWGCTRL_PORT", "3005"),
+		baseDir: cwd,
+		// awg-ctrl на loopback: системный прокси сюда не нужен.
+		httpLocal:     &http.Client{Transport: &http.Transport{Proxy: nil}},
+		revoked:       map[string]bool{},
+		loginAttempts: map[string]*rateEntry{},
+	}
+	if a.port == 0 {
+		a.port = 8080
+	}
+	// Как `process.env.JWT_SECRET ?? random` в Node: заданный (даже пустой) секрет берётся как есть.
+	if s, ok := os.LookupEnv("JWT_SECRET"); ok {
+		a.jwtSecret = []byte(s)
+	} else {
+		b := make([]byte, 32)
+		rand.Read(b)
+		a.jwtSecret = []byte(hex.EncodeToString(b))
+	}
+
+	keyFile := envOr("INTERNAL_AUTH_KEY_FILE", filepath.Join(cwd, "internal_auth_private.key"))
+	if k, err := iauth.LoadPrivate(keyFile); err == nil {
+		a.internalKey = k
+	} else {
+		warnf("ui: приватный ключ внутренней авторизации не найден: %s — запросы к awg-ctrl будут отклоняться", keyFile)
+	}
+
+	dbFile := os.Getenv("UI_DB_FILE")
+	if dbFile == "" {
+		dbFile = filepath.Join(cwd, "ui.db")
+	}
+	db, err := openUIDB(dbFile)
+	if err != nil {
+		return nil, err
+	}
+	a.db = db
+	if err := a.initAPIKeys(); err != nil {
+		return nil, err
+	}
+
+	if a.nodes, err = newNodes(a); err != nil {
+		return nil, err
+	}
+	if a.sub, err = newSub(a); err != nil {
+		return nil, err
+	}
+	if a.metrics, err = newMetrics(a); err != nil {
+		return nil, err
+	}
+	a.monitor = newMonitor(a)
+	a.nodes.BeforeDelete(a.apiKeysBeforeDelete)
+	a.nodes.AfterDelete(a.apiKeysAfterDelete)
+	return a, nil
+}
+
+func openUIDB(path string) (*sql.DB, error) {
+	dsn := "file:" + (&url.URL{Path: path}).EscapedPath() +
+		"?_pragma=busy_timeout(5000)&_pragma=journal_mode(WAL)&_pragma=foreign_keys(1)"
+	db, err := sql.Open("sqlite", dsn)
+	if err != nil {
+		return nil, err
+	}
+	// Одно соединение: запросы и транзакции идут по очереди, как в однопоточном Node.
+	// Внутри tx() нельзя обращаться к a.db — только к переданному tx, иначе взаимоблокировка.
+	db.SetMaxOpenConns(1)
+	if err := db.Ping(); err != nil {
+		db.Close()
+		return nil, err
+	}
+	return db, nil
+}
+
+// tx — uidb.transaction(fn)(): всё или ничего.
+func (a *App) tx(fn func(tx *sql.Tx) error) error {
+	t, err := a.db.Begin()
+	if err != nil {
+		return err
+	}
+	if err := fn(t); err != nil {
+		t.Rollback()
+		return err
+	}
+	return t.Commit()
+}
+
+// ctrlLocal — запрос к awg-ctrl этой машины с внутренним токеном.
+func (a *App) ctrlLocal(method, path string, body any) (*CtrlResp, error) {
+	if a.internalKey == nil {
+		return nil, fmt.Errorf("приватный ключ внутренней авторизации не загружен")
+	}
+	var rd *strings.Reader
+	if body != nil {
+		b, err := jsjson.Marshal(body)
+		if err != nil {
+			return nil, err
+		}
+		rd = strings.NewReader(string(b))
+	}
+	var req *http.Request
+	var err error
+	if rd != nil {
+		req, err = http.NewRequest(method, a.ctrlURL+path, rd)
+	} else {
+		req, err = http.NewRequest(method, a.ctrlURL+path, nil)
+	}
+	if err != nil {
+		return nil, err
+	}
+	req.Header.Set("Authorization", "Bearer "+iauth.Mint(a.internalKey, "awg-ui", nowFn()))
+	req.Header.Set("Content-Type", "application/json")
+	resp, err := a.httpLocal.Do(req)
+	if err != nil {
+		return nil, err
+	}
+	defer resp.Body.Close()
+	raw, err := readAll(resp)
+	if err != nil {
+		return nil, err
+	}
+	return &CtrlResp{resp.StatusCode, decodeLikeAxios(raw)}, nil
+}
+
+// ── JWT панели (HS256) ──────────────────────────────────────────────────────
+
+func tokenSig(token string) string {
+	if p := strings.Split(token, "."); len(p) > 2 {
+		return p[2]
+	}
+	return token
+}
+
+func (a *App) sign() string {
+	h := b64url.EncodeToString([]byte(`{"alg":"HS256","typ":"JWT"}`))
+	p := b64url.EncodeToString(jsjson.MustMarshal(jsjson.Object{{Key: "exp", Val: now() + 86400}}))
+	m := hmac.New(sha256.New, a.jwtSecret)
+	m.Write([]byte(h + "." + p))
+	return h + "." + p + "." + b64url.EncodeToString(m.Sum(nil))
+}
+
+func (a *App) verify(token string) bool {
+	a.mu.Lock()
+	rev := a.revoked[tokenSig(token)]
+	a.mu.Unlock()
+	if rev {
+		return false
+	}
+	parts := strings.Split(token, ".")
+	if len(parts) < 3 || parts[0] == "" || parts[1] == "" || parts[2] == "" {
+		return false
+	}
+	m := hmac.New(sha256.New, a.jwtSecret)
+	m.Write([]byte(parts[0] + "." + parts[1]))
+	if !hmac.Equal(fromB64url(parts[2]), m.Sum(nil)) {
+		return false
+	}
+	v, err := jsjson.Decode(fromB64url(parts[1]))
+	if err != nil {
+		return false
+	}
+	exp, ok := field(v, "exp").(float64)
+	return ok && exp > float64(now())
+}
+
+func bearer(r *http.Request) string {
+	h := r.Header.Get("Authorization")
+	if strings.HasPrefix(h, "Bearer ") {
+		return h[7:]
+	}
+	return ""
+}
+
+func (a *App) requireAuth(c *Ctx) bool {
+	tok := bearer(c.R)
+	if tok == "" || !a.verify(tok) {
+		return c.Error(401, "Unauthorized")
+	}
+	return true
+}
+
+// ── Лимит входа ─────────────────────────────────────────────────────────────
+
+const (
+	rateLimit  = 5
+	rateWindow = 15 * time.Minute
+)
+
+type rateEntry struct {
+	count   int
+	resetAt time.Time
+}
+
+func (a *App) checkRate(ip string) (bool, int) {
+	a.mu.Lock()
+	defer a.mu.Unlock()
+	t := nowFn()
+	e := a.loginAttempts[ip]
+	if e == nil || e.resetAt.Before(t) {
+		a.loginAttempts[ip] = &rateEntry{1, t.Add(rateWindow)}
+		return true, 0
+	}
+	if e.count >= rateLimit {
+		ms := e.resetAt.Sub(t).Milliseconds()
+		return false, int((ms + 999) / 1000)
+	}
+	e.count++
+	return true, 0
+}
+
+// ── Ключи внешнего API (/api/v1) ────────────────────────────────────────────
+// Живут в собственной БД awg-ui: awg-ctrl про них ничего не знает. Открытое значение
+// ключа не хранится — только SHA-256 и префикс для показа в панели.
+
+type apiKeyRow struct {
+	ID        int64
+	Label     string
+	KeyHash   string
+	Prefix    string
+	ServerID  int
+	CreatedAt int64
+	LastUsed  sql.NullInt64
+}
+
+func (a *App) initAPIKeys() error {
+	_, err := a.db.Exec(`
+    CREATE TABLE IF NOT EXISTS api_keys (
+        id         INTEGER PRIMARY KEY AUTOINCREMENT,
+        label      TEXT    NOT NULL,
+        key_hash   TEXT    NOT NULL UNIQUE,
+        prefix     TEXT    NOT NULL,
+        server_id  INTEGER NOT NULL DEFAULT 0,
+        created_at INTEGER NOT NULL,
+        last_used  INTEGER
+    );
+    -- Какие серверы видит ключ: на них он заводит vpn://-пользователей и в их пределах
+    -- управляет мастер-ключами. api_keys.server_id — сервер по умолчанию для /api/v1/users,
+    -- всегда входит в набор.
+    CREATE TABLE IF NOT EXISTS api_key_servers (
+        key_id    INTEGER NOT NULL REFERENCES api_keys(id) ON DELETE CASCADE,
+        server_id INTEGER NOT NULL,
+        PRIMARY KEY (key_id, server_id)
+    );
+    -- Ключи со времён одного сервера: набор — их server_id.
+    INSERT OR IGNORE INTO api_key_servers (key_id, server_id)
+        SELECT id, server_id FROM api_keys WHERE id NOT IN (SELECT key_id FROM api_key_servers);
+`)
+	return err
+}
+
+func scanKey(row interface{ Scan(...any) error }) (*apiKeyRow, error) {
+	k := &apiKeyRow{}
+	if err := row.Scan(&k.ID, &k.Label, &k.KeyHash, &k.Prefix, &k.ServerID, &k.CreatedAt, &k.LastUsed); err != nil {
+		return nil, err
+	}
+	return k, nil
+}
+
+const keyCols = "id, label, key_hash, prefix, server_id, created_at, last_used"
+
+func (a *App) keyByID(q queryer, id int64) *apiKeyRow {
+	k, _ := scanKey(q.QueryRow("SELECT "+keyCols+" FROM api_keys WHERE id = ?", id))
+	return k
+}
+
+type queryer interface {
+	Query(query string, args ...any) (*sql.Rows, error)
+	QueryRow(query string, args ...any) *sql.Row
+	Exec(query string, args ...any) (sql.Result, error)
+}
+
+// ints — первая колонка всех строк.
+func ints(q queryer, query string, args ...any) []int {
+	rows, err := q.Query(query, args...)
+	if err != nil {
+		return nil
+	}
+	defer rows.Close()
+	out := []int{}
+	for rows.Next() {
+		var n int
+		if rows.Scan(&n) == nil {
+			out = append(out, n)
+		}
+	}
+	return out
+}
+
+func (a *App) keyServers(q queryer, id int64) []int {
+	return ints(q, "SELECT server_id FROM api_key_servers WHERE key_id = ? ORDER BY server_id", id)
+}
+
+// setKeyServers — набор серверов ключа целиком. Сервер по умолчанию остаётся, если он в
+// наборе, иначе — наименьший из набора.
+func (a *App) setKeyServers(id int64, ids []int) error {
+	row := a.keyByID(a.db, id)
+	if row == nil {
+		return nil
+	}
+	return a.tx(func(tx *sql.Tx) error {
+		if _, err := tx.Exec("DELETE FROM api_key_servers WHERE key_id = ?", id); err != nil {
+			return err
+		}
+		for _, sid := range ids {
+			if _, err := tx.Exec("INSERT OR IGNORE INTO api_key_servers (key_id, server_id) VALUES (?, ?)", id, sid); err != nil {
+				return err
+			}
+		}
+		if !containsInt(ids, row.ServerID) {
+			_, err := tx.Exec("UPDATE api_keys SET server_id = ? WHERE id = ?", ids[0], id)
+			return err
+		}
+		return nil
+	})
+}
+
+func containsInt(s []int, v int) bool {
+	for _, x := range s {
+		if x == v {
+			return true
+		}
+	}
+	return false
+}
+
+// uniqueInts — [...new Set(v)] для массива из JSON: все элементы — целые серверы из реестра.
+// Иначе — ok=false.
+func (a *App) serverList(v any, exists func(int) bool) ([]int, bool) {
+	list := arr(v)
+	seen := map[float64]bool{}
+	var ids []int
+	for _, x := range list {
+		f, isNum := x.(float64)
+		if !isNum || !isInt(x) || !exists(int(f)) {
+			return nil, false
+		}
+		if !seen[f] {
+			seen[f] = true
+			ids = append(ids, int(f))
+		}
+	}
+	sort.Ints(ids)
+	return ids, true
+}
+
+// parseKeyServers — набор серверов из тела: непустой, без повторов, только существующие.
+func (a *App) parseKeyServers(v any) ([]int, string) {
+	if l, ok := v.([]any); !ok || len(l) == 0 {
+		return nil, "Нужен хотя бы один сервер"
+	}
+	ids, ok := a.serverList(v, a.nodes.Exists)
+	if !ok {
+		return nil, "Такого сервера нет"
+	}
+	return ids, ""
+}
+
+func hashKey(key string) string {
+	s := sha256.Sum256([]byte(key))
+	return hex.EncodeToString(s[:])
+}
+
+func genAPIKey() (key, hash, prefix string) {
+	b := make([]byte, 24)
+	rand.Read(b)
+	key = "awgk_" + b64url.EncodeToString(b)
+	return key, hashKey(key), key[:13] + "…"
+}
+
+var reKeyLabel = regexp.MustCompile(`^[\w \-]{1,40}$`)
+
+func intsJSON(s []int) []any {
+	out := make([]any, len(s))
+	for i, v := range s {
+		out[i] = v
+	}
+	return out
+}
+
+func nullInt(n sql.NullInt64) any {
+	if n.Valid {
+		return n.Int64
+	}
+	return nil
+}
+
+func (a *App) apiKeysList(c *Ctx) bool {
+	rows, err := a.db.Query("SELECT " + keyCols + " FROM api_keys ORDER BY id")
+	if err != nil {
+		return c.Error(500, "Internal server error")
+	}
+	var keys []*apiKeyRow
+	for rows.Next() {
+		if k, err := scanKey(rows); err == nil {
+			keys = append(keys, k)
+		}
+	}
+	rows.Close()
+	out := []any{}
+	for _, k := range keys {
+		out = append(out, jsjson.Object{
+			{Key: "id", Val: k.ID}, {Key: "label", Val: k.Label}, {Key: "prefix", Val: k.Prefix},
+			{Key: "server_id", Val: k.ServerID}, {Key: "created_at", Val: k.CreatedAt}, {Key: "last_used", Val: nullInt(k.LastUsed)},
+			{Key: "servers", Val: intsJSON(a.keyServers(a.db, k.ID))},
+		})
+	}
+	return c.JSON(200, jsjson.Object{{Key: "keys", Val: out}})
+}
+
+// jsString — String(v) для меток: строка, число или логическое значение. Остальное — не метка.
+func jsString(v any) (string, bool) {
+	switch x := v.(type) {
+	case string:
+		return x, true
+	case float64:
+		return jsjson.Number(x), true
+	case bool:
+		return strconv.FormatBool(x), true
+	}
+	return "", false
+}
+
+// servers — набор серверов ключа; без него — server_id (по-старому) или сервер по умолчанию.
+func (a *App) apiKeysCreate(c *Ctx) bool {
+	b := c.Obj()
+	label, labelOK := jsString(b.Get2("label"))
+	if !truthy(b.Get2("label")) || !labelOK || !reKeyLabel.MatchString(label) {
+		return c.Error(400, "Метка: буквы, цифры, пробел, _ и -, до 40 символов")
+	}
+	// server_id === undefined в JSON — только отсутствие ключа; null — это Number(null) = 0.
+	sidRaw, sidPresent := b.Get("server_id")
+	var serversV any
+	if s := b.Get2("servers"); s != nil {
+		serversV = s
+	} else if !sidPresent {
+		serversV = []any{float64(a.nodes.DefaultID())}
+	} else {
+		serversV = []any{jsToNumberAny(sidRaw)}
+	}
+	ids, msg := a.parseKeyServers(serversV)
+	if msg != "" {
+		return c.Error(400, msg)
+	}
+	sid := ids[0]
+	if sidPresent {
+		if f := jsToNumberAny(sidRaw); f == float64(int(f)) && containsInt(ids, int(f)) {
+			sid = int(f)
+		}
+	}
+	key, hash, prefix := genAPIKey()
+	var id int64
+	err := a.tx(func(tx *sql.Tx) error {
+		r, err := tx.Exec("INSERT INTO api_keys (label, key_hash, prefix, server_id, created_at) VALUES (?, ?, ?, ?, ?)",
+			label, hash, prefix, sid, now())
+		if err != nil {
+			return err
+		}
+		id, _ = r.LastInsertId()
+		for _, s := range ids {
+			if _, err := tx.Exec("INSERT OR IGNORE INTO api_key_servers (key_id, server_id) VALUES (?, ?)", id, s); err != nil {
+				return err
+			}
+		}
+		return nil
+	})
+	if err != nil {
+		return c.Error(500, "Internal server error")
+	}
+	// Открытое значение отдаётся один раз — дальше в БД только хэш.
+	return c.JSON(201, jsjson.Object{{Key: "id", Val: id}, {Key: "label", Val: b.Get2("label")}, {Key: "prefix", Val: prefix},
+		{Key: "key", Val: key}, {Key: "server_id", Val: sid}, {Key: "servers", Val: intsJSON(ids)}})
+}
+
+// paramID — Number(req.params.id): ok, если целое.
+func paramID(s string) (int64, bool) {
+	f := jsToNumber(s)
+	if f != f || f != float64(int64(f)) {
+		return 0, false
+	}
+	return int64(f), true
+}
+
+func (a *App) apiKeysPatch(c *Ctx) bool {
+	id, ok := paramID(c.Params["id"])
+	if !ok || a.keyByID(a.db, id) == nil {
+		return c.Error(404, "Не найден")
+	}
+	ids, msg := a.parseKeyServers(c.Obj().Get2("servers"))
+	if msg != "" {
+		return c.Error(400, msg)
+	}
+	if err := a.setKeyServers(id, ids); err != nil {
+		return c.Error(500, "Internal server error")
+	}
+	row := a.keyByID(a.db, id)
+	return c.JSON(200, jsjson.Object{{Key: "id", Val: id}, {Key: "server_id", Val: row.ServerID}, {Key: "servers", Val: intsJSON(ids)}})
+}
+
+func (a *App) apiKeysDelete(c *Ctx) bool {
+	id, ok := paramID(c.Params["id"])
+	if !ok {
+		return c.Error(400, "Неверный id")
+	}
+	a.tx(func(tx *sql.Tx) error {
+		tx.Exec("DELETE FROM api_key_servers WHERE key_id = ?", id)
+		_, err := tx.Exec("DELETE FROM api_keys WHERE id = ?", id)
+		return err
+	})
+	return c.JSON(200, jsjson.Object{{Key: "success", Val: true}, {Key: "id", Val: id}})
+}
+
+// Сервер удаляют из реестра: ключ API, для которого он единственный, — повод отказать
+// (ключ остался бы без серверов); у остальных он убирается из набора, когда сервер удалён.
+type keyOnServer struct {
+	id       int64
+	label    string
+	serverID int
+	n        int
+}
+
+func (a *App) keysOnServer(id int) []keyOnServer {
+	rows, err := a.db.Query("SELECT k.id, k.label, k.server_id, (SELECT COUNT(*) FROM api_key_servers x WHERE x.key_id = k.id) AS n FROM api_keys k JOIN api_key_servers s ON s.key_id = k.id WHERE s.server_id = ?", id)
+	if err != nil {
+		return nil
+	}
+	defer rows.Close()
+	var out []keyOnServer
+	for rows.Next() {
+		var k keyOnServer
+		if rows.Scan(&k.id, &k.label, &k.serverID, &k.n) == nil {
+			out = append(out, k)
+		}
+	}
+	return out
+}
+
+func (a *App) apiKeysBeforeDelete(id int, _ bool) *deleteVeto {
+	var only []string
+	for _, k := range a.keysOnServer(id) {
+		if k.n == 1 {
+			only = append(only, k.label)
+		}
+	}
+	if len(only) > 0 {
+		return &deleteVeto{Error: "Это единственный сервер ключей API: " + strings.Join(only, ", ") + " — сначала удалите их или добавьте им другой сервер"}
+	}
+	return nil
+}
+
+func (a *App) apiKeysAfterDelete(id int) {
+	for _, k := range a.keysOnServer(id) {
+		var rest []int
+		for _, s := range a.keyServers(a.db, k.id) {
+			if s != id {
+				rest = append(rest, s)
+			}
+		}
+		a.setKeyServers(k.id, rest)
+	}
+}
+
+// ── Внешний API: ключ и сервер ──────────────────────────────────────────────
+
+func (a *App) requireAPIKey(c *Ctx) bool {
+	key := c.R.Header.Get("X-Api-Key")
+	if !strings.HasPrefix(key, "awgk_") {
+		return c.Error(401, "API key required")
+	}
+	row, err := scanKey(a.db.QueryRow("SELECT "+keyCols+" FROM api_keys WHERE key_hash = ?", hashKey(key)))
+	if err != nil {
+		return c.Error(401, "Invalid API key")
+	}
+	a.db.Exec("UPDATE api_keys SET last_used = ? WHERE id = ?", now(), row.ID)
+	c.apiKey = row
+	c.servers = a.keyServers(a.db, row.ID)
+	return true
+}
+
+// pickKeyServer — сервер для /api/v1/users: X-Server-Id из набора ключа, без заголовка —
+// сервер ключа по умолчанию. Сервер вне набора — как несуществующий.
+func (a *App) pickKeyServer(c *Ctx) bool {
+	id := c.apiKey.ServerID
+	if raw, ok := c.R.Header["X-Server-Id"]; ok {
+		f := jsToNumber(strings.Join(raw, ", "))
+		if f != float64(int(f)) {
+			return c.Error(404, "Сервер не найден")
+		}
+		id = int(f)
+	}
+	if !containsInt(c.servers, id) {
+		return c.Error(404, "Сервер не найден")
+	}
+	c.serverID = id
+	return true
+}
+
+// serverIDOf — сервер запроса панели: X-Server-Id (0 — локальный awg-ctrl), без него — по умолчанию.
+func (a *App) serverIDOf(c *Ctx) int {
+	raw, ok := c.R.Header["X-Server-Id"]
+	if !ok {
+		return a.nodes.DefaultID()
+	}
+	f := jsToNumber(strings.Join(raw, ", "))
+	if f == float64(int(f)) && f >= 0 {
+		return int(f)
+	}
+	return a.nodes.DefaultID()
+}
+
+func (a *App) proxy(c *Ctx) bool {
+	r, err := a.nodes.CtrlFor(a.serverIDOf(c))(c.R.Method, c.R.RequestURI, c.Body)
+	if err != nil {
+		return c.Error(502, "awg-ctrl недоступен")
+	}
+	return c.JSON(r.Status, r.Data)
+}
+
+// extUser — внешний контракт: наружу только name/ip/gen/vpn_key, psk_key и pub_key остаются внутри.
+func extUser(d any) jsjson.Object {
+	o := jsjson.Object{}
+	for _, k := range [][2]string{{"name", "name"}, {"ip", "ip"}, {"gen", "key_gen"}, {"vpn_key", "vpn_key"}} {
+		if hasField(d, k[1]) { // undefined JSON.stringify опускает
+			o = append(o, jsjson.KV{Key: k[0], Val: field(d, k[1])})
+		}
+	}
+	return o
+}
+
+func hasField(v any, k string) bool {
+	o, ok := v.(jsjson.Object)
+	return ok && has(o, k)
+}
+
+func (a *App) extCtrl(c *Ctx) Ctrl { return a.nodes.CtrlFor(c.serverID) }
+
+// unavailable — ответ, когда awg-ctrl не ответил (как wrap() в Node-версии).
+func unavailable(c *Ctx) bool { return c.Error(502, "awg-ctrl недоступен") }
+
+func (a *App) extUsersCreate(c *Ctx) bool {
+	body := jsjson.Object{}
+	if v, ok := c.Obj().Get("name"); ok {
+		body = append(body, jsjson.KV{Key: "name", Val: v})
+	}
+	r, err := a.extCtrl(c)("POST", "/api/users", body)
+	if err != nil {
+		return unavailable(c)
+	}
+	if r.Status >= 400 {
+		return c.JSON(r.Status, r.Data)
+	}
+	return c.JSON(201, extUser(r.Data))
+}
+
+func (a *App) extUsersList(c *Ctx) bool {
+	r, err := a.extCtrl(c)("GET", "/api/users/stats", nil)
+	if err != nil {
+		return unavailable(c)
+	}
+	return c.JSON(r.Status, r.Data)
+}
+
+func (a *App) extUsersGet(c *Ctx) bool {
+	r, err := a.extCtrl(c)("POST", "/api/users/"+encodeURIComponent(c.Params["name"]), nil)
+	if err != nil {
+		return unavailable(c)
+	}
+	if r.Status >= 400 {
+		return c.JSON(r.Status, r.Data)
+	}
+	return c.JSON(200, extUser(r.Data))
+}
+
+func (a *App) extUsersDelete(c *Ctx) bool {
+	r, err := a.extCtrl(c)("DELETE", "/api/users/"+encodeURIComponent(c.Params["name"]), nil)
+	if err != nil {
+		return unavailable(c)
+	}
+	return c.JSON(r.Status, r.Data)
+}
+
+// ── Маршруты ────────────────────────────────────────────────────────────────
+
+func (a *App) login(c *Ctx) bool {
+	ip := c.remoteIP()
+	if ok, retry := a.checkRate(ip); !ok {
+		return c.Error(429, fmt.Sprintf("Слишком много попыток. Повтори через %d сек.", retry))
+	}
+	b := c.Obj()
+	user, uok := b.Get2("user").(string)
+	pass, pok := b.Get2("pass").(string)
+	if a.uiPass == "" || !uok || !pok || user != a.uiUser || pass != a.uiPass {
+		return c.Error(401, "Неверный логин или пароль")
+	}
+	a.mu.Lock()
+	delete(a.loginAttempts, ip)
+	a.mu.Unlock()
+	return c.JSON(200, jsjson.Object{{Key: "token", Val: a.sign()}})
+}
+
+func (a *App) logout(c *Ctx) bool {
+	a.mu.Lock()
+	a.revoked[tokenSig(bearer(c.R))] = true
+	a.mu.Unlock()
+	return c.JSON(200, jsjson.Object{{Key: "ok", Val: true}})
+}
+
+func (a *App) routes() *Router {
+	app := newRouter()
+	auth := a.requireAuth
+
+	app.Post("/login", a.login)
+	app.Post("/logout", auth, a.logout)
+	// Единственный роут без авторизации: вордмарк нужен уже на экране логина.
+	app.Get("/ui/brand", func(c *Ctx) bool {
+		return c.JSON(200, jsjson.Object{{Key: "brand", Val: a.brand}, {Key: "channel", Val: a.channel}, {Key: "version", Val: a.version}})
+	})
+	app.Get("/ui/apikeys", auth, a.apiKeysList)
+	app.Post("/ui/apikeys", auth, a.apiKeysCreate)
+	app.Patch("/ui/apikeys/:id", auth, a.apiKeysPatch)
+	app.Delete("/ui/apikeys/:id", auth, a.apiKeysDelete)
+
+	// ВАЖНО: /api/v1 — до JWT-прокси на /api, иначе прокси потребует JWT вместо ключа.
+	app.Use("/api/v1", a.requireAPIKey)
+	app.Use("/api/v1/users", a.pickKeyServer)
+	app.Post("/api/v1/users", a.extUsersCreate)
+	app.Get("/api/v1/users", a.extUsersList)
+	app.Get("/api/v1/users/:name", a.extUsersGet)
+	app.Delete("/api/v1/users/:name", a.extUsersDelete)
+	app.Mount("/api/v1/masterkeys", a.sub.apiRouter(func(c *Ctx) []int { return c.servers }))
+
+	app.Use("/ui/nodes", auth)
+	app.Mount("/ui/nodes", a.nodes.router())
+	app.Use("/ui/masterkeys", auth)
+	app.Mount("/ui/masterkeys", a.sub.masterKeysRouter())
+	app.Use("/ui/devices", auth)
+	app.Mount("/ui/devices", a.sub.devicesRouter())
+
+	// Prometheus: /metrics за отдельным токеном «только метрики» (не JWT и не ключ API).
+	app.Use("/ui/metrics-token", auth)
+	app.Mount("/ui/metrics-token", a.metrics.router())
+	app.Get("/metrics", a.metrics.requireToken, a.metrics.handler)
+	app.Use("/ui/monitor", auth)
+	app.Mount("/ui/monitor", a.monitor.router())
+
+	for _, p := range []string{"/api", "/health", "/awg"} {
+		app.Use(p, auth, a.proxy)
+	}
+	app.Use("/", a.static)
+	return app
+}
+
+// static — express.static(dist) и SPA-фолбэк app.get("*") → dist/index.html.
+func (a *App) static(c *Ctx) bool {
+	if c.R.Method != "GET" && c.R.Method != "HEAD" {
+		return true
+	}
+	dist := filepath.Join(a.baseDir, "dist")
+	p, err := url.PathUnescape(c.R.URL.EscapedPath())
+	if err == nil && !strings.Contains(p, "\x00") {
+		clean := filepath.Clean("/" + p)
+		hidden := false
+		for _, s := range strings.Split(clean, "/") {
+			if strings.HasPrefix(s, ".") {
+				hidden = true
+			}
+		}
+		f := filepath.Join(dist, clean)
+		if st, err := os.Stat(f); err == nil && !hidden {
+			if st.IsDir() {
+				if !strings.HasSuffix(c.R.URL.Path, "/") {
+					http.Redirect(c.W, c.R, c.R.URL.Path+"/", http.StatusMovedPermanently)
+					return false
+				}
+				f = filepath.Join(f, "index.html")
+			}
+			if st, err := os.Stat(f); err == nil && !st.IsDir() {
+				serveFile(c.W, c.R, f)
+				return false
+			}
+		}
+	}
+	index := filepath.Join(dist, "index.html")
+	if _, err := os.Stat(index); err != nil {
+		writeHTMLError(c.W, 404, "Error: ENOENT: no such file or directory, stat '"+index+"'")
+		return false
+	}
+	serveFile(c.W, c.R, index)
+	return false
+}
+
+func serveFile(w http.ResponseWriter, r *http.Request, f string) {
+	fh, err := os.Open(f)
+	if err != nil {
+		writeHTMLError(w, 404, "Not Found")
+		return
+	}
+	defer fh.Close()
+	st, _ := fh.Stat()
+	w.Header().Set("Cache-Control", "public, max-age=0")
+	http.ServeContent(w, r, st.Name(), st.ModTime(), fh)
+}
+
+// Run слушает панель на :PORT и запускает фоновые части (хаб нод, подписку).
+func (a *App) Run() error {
+	ln, err := net.Listen("tcp", fmt.Sprintf(":%d", a.port))
+	if err != nil {
+		return err
+	}
+	srv := &http.Server{Handler: a.routes(), ReadHeaderTimeout: 30 * time.Second}
+	logf("ui: listening on :%d", a.port)
+	a.nodes.Start()
+	a.sub.Start()
+	return srv.Serve(ln)
+}

internal/ui/sub_admin.go

@@ -0,0 +1,811 @@
+package ui
+
+// Мастер-ключи: общая логика панели и внешнего API (порт части awg-ui/sub.ts). Панель
+// (/ui/masterkeys, /ui/devices, за JWT) видит всё. Внешний API (/api/v1/masterkeys, ключ
+// awgk_) — только ключи, чьи серверы целиком входят в набор серверов API-ключа: иначе он мог бы
+// удалить или перенастроить раздачу на сервере, которого не видит. scope: nil — панель.
+
+import (
+	"crypto/rand"
+	"database/sql"
+	"errors"
+	"fmt"
+	"regexp"
+	"sort"
+	"strings"
+	"sync"
+
+	"github.com/google/uuid"
+
+	"github.com/maeneko/forgetting/internal/jsjson"
+)
+
+type apiError struct {
+	status int
+	msg    string
+}
+
+func (e *apiError) Error() string { return e.msg }
+
+func fail(status int, msg string) error { return &apiError{status, msg} }
+
+// aw — apiError даёт свой статус; остальное (awg-ctrl не ответил посреди действия) — 502.
+func aw(fn func(c *Ctx) (int, any, error)) handler {
+	return func(c *Ctx) bool {
+		var (
+			st  int
+			v   any
+			err error
+		)
+		func() {
+			defer func() {
+				if p := recover(); p != nil {
+					err = fmt.Errorf("%v", p)
+				}
+			}()
+			st, v, err = fn(c)
+		}()
+		var ae *apiError
+		if errors.As(err, &ae) {
+			return c.Error(ae.status, ae.msg)
+		}
+		if err != nil {
+			return c.Error(502, "awg-ctrl недоступен")
+		}
+		return c.JSON(st, v)
+	}
+}
+
+var (
+	reUUID  = regexp.MustCompile(`(?i)^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$`)
+	reLabel = regexp.MustCompile(`^[^\r\n<>]+$`) // длина — lenOK(1, 40): в JS {1,40} считает UTF-16
+)
+
+func labelOK(v any) (string, bool) {
+	s, ok := v.(string)
+	return s, ok && reLabel.MatchString(s) && lenOK(s, 1, 40)
+}
+
+// idOf — Number(v), если это безопасное целое, иначе -1 (не найдётся).
+func idOf(v string) int64 {
+	f := jsToNumber(v)
+	if !isSafeInt(f) {
+		return -1
+	}
+	return int64(f)
+}
+
+// masterIdOf — мастер-ключ в пути: числовой id или uuid.
+func (s *Sub) masterIDOf(v string) int64 {
+	if reUUID.MatchString(v) {
+		var id int64
+		if s.a.db.QueryRow("SELECT id FROM master_keys WHERE uuid = ?", strings.ToLower(v)).Scan(&id) != nil {
+			return -1
+		}
+		return id
+	}
+	return idOf(v)
+}
+
+func limitOK(v any) (int64, bool) {
+	f, ok := v.(float64)
+	return int64(f), ok && f == float64(int64(f)) && f >= 1 && f <= 100
+}
+
+func (s *Sub) visible(masterID int64, scope []int) bool {
+	if scope == nil {
+		return true
+	}
+	for _, id := range s.serverIDsOf(s.a.db, masterID) {
+		if !containsInt(scope, id) {
+			return false
+		}
+	}
+	return true
+}
+
+// masterFor — живой (не удаляемый) ключ в пределах области; чужой — как несуществующий.
+func (s *Sub) masterFor(id int64, scope []int) (*masterRow, error) {
+	m := s.masterByID(s.a.db, id)
+	if m == nil || !s.visible(m.ID, scope) {
+		return nil, fail(404, "Не найден")
+	}
+	return m, nil
+}
+
+// deviceFor — устройство; у внешнего API — только вместе со своим мастер-ключом.
+func (s *Sub) deviceFor(id int64, master *masterRow) (*deviceRow, error) {
+	d := s.deviceByID(s.a.db, id)
+	if d == nil || master != nil && d.MasterID != master.ID {
+		return nil, fail(404, "Не найдено")
+	}
+	return d, nil
+}
+
+// parseServers — набор серверов из тела: непустой, без повторов, только существующие и — для
+// внешнего API — только из области его ключа.
+func (s *Sub) parseServers(v any, scope []int) ([]int, error) {
+	list, ok := v.([]any)
+	if !ok || len(list) == 0 {
+		return nil, fail(400, "Нужен хотя бы один сервер")
+	}
+	if len(list) > maxServers {
+		return nil, fail(400, fmt.Sprintf("Не больше %d серверов", maxServers))
+	}
+	ids, ok := s.a.serverList(v, s.a.nodes.Exists)
+	if !ok {
+		return nil, fail(400, "Такого сервера нет")
+	}
+	if scope != nil {
+		for _, id := range ids {
+			if !containsInt(scope, id) {
+				return nil, fail(403, "Сервер вне области API-ключа")
+			}
+		}
+	}
+	return ids, nil
+}
+
+// masterOut — deleting: ключ удалён, но эти серверы ещё не подтвердили, что сняли его пиров.
+func (s *Sub) masterOut(m *masterRow) jsjson.Object {
+	srv := intsJSON(s.serverIDsOf(s.a.db, m.ID))
+	o := jsjson.Object{{Key: "id", Val: m.ID}, {Key: "uuid", Val: m.UUID}, {Key: "label", Val: m.Label}, {Key: "device_limit", Val: m.DeviceLimit},
+		{Key: "devices", Val: m.Devices}, {Key: "servers", Val: srv}, {Key: "created_at", Val: m.CreatedAt}}
+	if m.RevokedAt.Valid {
+		o = append(o, jsjson.KV{Key: "deleting", Val: srv})
+	}
+	return o
+}
+
+func (s *Sub) masterOutByID(id int64) jsjson.Object { return s.masterOut(s.masterRowByID(s.a.db, id)) }
+
+func (s *Sub) listMasters(scope []int) []any {
+	rows, err := s.a.db.Query("SELECT " + masterCols + ", (SELECT COUNT(*) FROM devices d WHERE d.master_id = m.id) AS devices FROM master_keys m ORDER BY id")
+	if err != nil {
+		return []any{}
+	}
+	var ms []*masterRow
+	for rows.Next() {
+		if m := scanMaster(rows, true); m != nil {
+			ms = append(ms, m)
+		}
+	}
+	rows.Close()
+	out := []any{}
+	for _, m := range ms {
+		if s.visible(m.ID, scope) {
+			out = append(out, s.masterOut(m))
+		}
+	}
+	return out
+}
+
+// createMaster — серверы по умолчанию: у панели — сервер по умолчанию, у API-ключа — вся его область.
+func (s *Sub) createMaster(body any, scope []int) (jsjson.Object, error) {
+	b, _ := body.(jsjson.Object)
+	label, ok := labelOK(b.Get2("label"))
+	if !ok {
+		return nil, fail(400, "Метка: до 40 символов, без переводов строк и <>")
+	}
+	limitV, hasLimit := b.Get("device_limit")
+	limit := int64(defaultLimit)
+	if hasLimit {
+		var ok bool
+		if limit, ok = limitOK(limitV); !ok {
+			return nil, fail(400, "Лимит устройств: от 1 до 100")
+		}
+	}
+	wanted, hasWanted := b.Get("servers")
+	src := wanted
+	if src == nil {
+		if scope != nil {
+			list := []any{} // как пришло бы из JSON: числа — float64
+			for _, id := range scope {
+				list = append(list, float64(id))
+			}
+			src = list
+		} else {
+			src = []any{float64(s.a.nodes.DefaultID())}
+		}
+	}
+	ids, err := s.parseServers(src, scope)
+	if err != nil {
+		if !hasWanted && scope == nil {
+			return nil, fail(400, "Сначала добавьте сервер")
+		}
+		return nil, err
+	}
+	secret := make([]byte, 16)
+	rand.Read(secret)
+	var id int64
+	err = s.a.tx(func(tx *sql.Tx) error {
+		r, err := tx.Exec("INSERT INTO master_keys (uuid, label, secret, device_limit, server_id, created_at) VALUES (?, ?, ?, ?, ?, ?)",
+			uuid.NewString(), label, secret, limit, ids[0], now())
+		if err != nil {
+			return err
+		}
+		id, _ = r.LastInsertId()
+		for _, sid := range ids {
+			if _, err := tx.Exec("INSERT OR IGNORE INTO master_servers (master_id, server_id) VALUES (?, ?)", id, sid); err != nil {
+				return err
+			}
+		}
+		return nil
+	})
+	if err != nil {
+		return nil, err
+	}
+	return s.masterOutByID(id), nil
+}
+
+func (s *Sub) updateMaster(m *masterRow, body any, scope []int) (jsjson.Object, error) {
+	b, _ := body.(jsjson.Object)
+	nlV := b.Get2("label")
+	if nlV == nil {
+		nlV = m.Label
+	}
+	ndV := b.Get2("device_limit")
+	if ndV == nil {
+		ndV = float64(m.DeviceLimit)
+	}
+	nl, ok := labelOK(nlV)
+	if !ok {
+		return nil, fail(400, "Неверная метка")
+	}
+	nd, ok := limitOK(ndV)
+	if !ok {
+		return nil, fail(400, "Лимит устройств: от 1 до 100")
+	}
+
+	ids := s.serverIDsOf(s.a.db, m.ID)
+	var affected []int
+	if wanted, has := b.Get("servers"); has {
+		next, err := s.parseServers(wanted, scope)
+		if err != nil {
+			return nil, err
+		}
+		var added, removed []int
+		for _, x := range next {
+			if !containsInt(ids, x) {
+				added = append(added, x)
+			}
+		}
+		for _, x := range ids {
+			if !containsInt(next, x) {
+				removed = append(removed, x)
+			}
+		}
+		devices := s.devicesOf(s.a.db, m.ID)
+		if err := s.a.tx(func(tx *sql.Tx) error {
+			for _, sid := range removed {
+				tx.Exec("DELETE FROM master_servers WHERE master_id = ? AND server_id = ?", m.ID, sid)
+				for _, d := range devices {
+					for _, l := range s.linksOf(tx, d.ID) {
+						if l.ServerID == sid && l.PeerPub.Valid {
+							tx.Exec("INSERT OR IGNORE INTO peer_tombstones (server_id, pub_key) VALUES (?, ?)", sid, l.PeerPub.String)
+						}
+					}
+					tx.Exec("DELETE FROM device_peers WHERE device_id = ? AND server_id = ?", d.ID, sid)
+				}
+			}
+			for _, sid := range added {
+				tx.Exec("INSERT OR IGNORE INTO master_servers (master_id, server_id) VALUES (?, ?)", m.ID, sid)
+				for _, d := range devices {
+					tx.Exec("INSERT OR IGNORE INTO device_peers (device_id, server_id) VALUES (?, ?)", d.ID, sid)
+				}
+			}
+			return nil
+		}); err != nil {
+			return nil, err
+		}
+		affected = append(append(affected, added...), removed...)
+		ids = next
+	}
+	s.a.db.Exec("UPDATE master_keys SET label = ?, device_limit = ? WHERE id = ?", nl, nd, m.ID)
+	// Лимит стал меньше, чем устройств: лишние отвязываются, начиная с подключившихся последними.
+	unbound := []any{}
+	devices := s.devicesOf(s.a.db, m.ID)
+	if int64(len(devices)) > nd {
+		newest := append([]*deviceRow{}, devices...)
+		sort.SliceStable(newest, func(i, j int) bool {
+			if newest[i].CreatedAt != newest[j].CreatedAt {
+				return newest[i].CreatedAt > newest[j].CreatedAt
+			}
+			return newest[i].ID > newest[j].ID
+		})
+		for _, d := range newest[:int64(len(devices))-nd] {
+			affected = append(affected, s.forgetDeviceTx(d)...)
+			unbound = append(unbound, d.ID)
+		}
+	}
+	s.reconcileAll(affected)
+	return jsjson.Object{{Key: "id", Val: m.ID}, {Key: "label", Val: nl}, {Key: "device_limit", Val: nd},
+		{Key: "servers", Val: intsJSON(ids)}, {Key: "unbound", Val: unbound}}, nil
+}
+
+// rotateMaster — новая ссылка; устройства продолжают работать: у них auth_pub, а не secret.
+func (s *Sub) rotateMaster(m *masterRow) {
+	secret := make([]byte, 16)
+	rand.Read(secret)
+	s.a.db.Exec("UPDATE master_keys SET secret = ? WHERE id = ?", secret, m.ID)
+}
+
+func (s *Sub) rekeyMaster(m *masterRow) {
+	s.a.db.Exec("UPDATE devices SET rekey_requested = 1 WHERE id = ? OR master_id = ?", -1, m.ID)
+}
+
+// deleteMaster — ключ сразу перестаёт работать, но строка остаётся отозванной, пока каждый его
+// сервер не подтвердит, что снял пиров.
+func (s *Sub) deleteMaster(m *masterRow) jsjson.Object {
+	affected := s.serverIDsOf(s.a.db, m.ID)
+	s.a.tx(func(tx *sql.Tx) error {
+		for _, d := range s.devicesOf(tx, m.ID) {
+			affected = append(affected, s.forgetDevice(tx, d)...)
+		}
+		_, err := tx.Exec("UPDATE master_keys SET revoked_at = ? WHERE id = ?", now(), m.ID)
+		return err
+	})
+	s.reconcileAll(affected)
+	return jsjson.Object{{Key: "success", Val: true}, {Key: "id", Val: m.ID}, {Key: "pending", Val: intsJSON(s.serverIDsOf(s.a.db, m.ID))}}
+}
+
+// linkProblem — выдать ссылку можно, только если подписка настроена и известен адрес панели.
+func (s *Sub) linkProblem(c *Ctx) string {
+	if s.key() == nil || s.signPub == nil || s.port == 0 {
+		return "Подписка не настроена на сервере"
+	}
+	if s.subHost(c) == "" {
+		return "Не удалось определить адрес панели — задайте SUB_HOST"
+	}
+	return ""
+}
+
+func (s *Sub) linkOf(m *masterRow, c *Ctx) (jsjson.Object, error) {
+	if p := s.linkProblem(c); p != "" {
+		return nil, fail(503, p)
+	}
+	link, err := EncodeSenLink(SenLink{TLS: s.tlsPin != nil, Addrs: []SenAddr{{s.subHost(c), s.port}},
+		Secret: m.Secret, SignPub: s.signPub, TLSPin: s.tlsPin, Name: m.Label})
+	if err != nil {
+		return nil, err // как в Node: не ApiError — 502
+	}
+	return jsjson.Object{{Key: "link", Val: link}, {Key: "tls", Val: s.tlsPin != nil}}, nil
+}
+
+type devStat struct {
+	online     bool
+	lastHS     float64
+	rx, tx     float64
+	background bool
+	torrent    bool
+}
+
+// masterDevices — статистика устройства по всем серверам ключа: онлайн, если есть свежий
+// handshake хоть на одном; трафик суммируется. servers_ok — где уже стоит его текущий ключ.
+func (s *Sub) masterDevices(m *masterRow) ([]any, error) {
+	stats := map[string]*devStat{}
+	var mu sync.Mutex
+	var wg sync.WaitGroup
+	var firstErr error
+	for _, id := range s.serverIDsOf(s.a.db, m.ID) {
+		if !s.a.nodes.IsOnline(id) {
+			continue
+		}
+		wg.Add(1)
+		go func() {
+			defer wg.Done()
+			r, err := s.a.nodes.CtrlFor(id)("GET", "/api/peers", nil)
+			mu.Lock()
+			defer mu.Unlock()
+			if err != nil {
+				if firstErr == nil {
+					firstErr = err
+				}
+				return
+			}
+			if !ok2xx(r.Status) {
+				return
+			}
+			for _, p := range arr(field(r.Data, "peers")) {
+				pub, _ := field(p, "pub_key").(string)
+				st := stats[pub]
+				if st == nil {
+					st = &devStat{}
+					stats[pub] = st
+				}
+				st.online = st.online || truthy(field(p, "online"))
+				if h := numOr(field(p, "lastHandshake"), 0); h > st.lastHS {
+					st.lastHS = h
+				}
+				st.rx += numOr(field(p, "rx"), 0)
+				st.tx += numOr(field(p, "tx"), 0)
+				// Устройство стоит на каждом сервере со своим IP; фоновым его делает любой из них.
+				st.background = st.background || field(p, "priority") == "background"
+				st.torrent = st.torrent || truthy(field(p, "torrent"))
+			}
+		}()
+	}
+	wg.Wait()
+	if firstErr != nil {
+		return nil, firstErr
+	}
+	out := []any{}
+	for _, d := range s.devicesOf(s.a.db, m.ID) {
+		links := s.linksOf(s.a.db, d.ID)
+		st := stats[d.PubKey]
+		if st == nil {
+			st = &devStat{}
+		}
+		okN := 0
+		ips := []any{} // IP устройства на каждом сервере ключа, где он уже выдан
+		for _, l := range links {
+			if l.PeerPub.Valid && l.PeerPub.String == d.PubKey && l.IP.Valid && l.IP.String != "" {
+				okN++
+			}
+			if l.IP.Valid && l.IP.String != "" {
+				ips = append(ips, jsjson.Object{{Key: "server_id", Val: l.ServerID}, {Key: "ip", Val: l.IP.String}})
+			}
+		}
+		prio := "normal"
+		if st.background {
+			prio = "background"
+		}
+		out = append(out, jsjson.Object{
+			{Key: "id", Val: d.ID}, {Key: "device_id", Val: d.DeviceID}, {Key: "device_name", Val: d.DeviceName}, {Key: "platform", Val: d.Platform},
+			{Key: "version", Val: d.Version}, {Key: "created_at", Val: d.CreatedAt}, {Key: "last_seen", Val: nullInt(d.LastSeen)},
+			{Key: "rekey_requested", Val: d.RekeyRequested == 1}, {Key: "online", Val: st.online}, {Key: "lastHandshake", Val: st.lastHS},
+			{Key: "rx", Val: st.rx}, {Key: "tx", Val: st.tx}, {Key: "priority", Val: prio},
+			{Key: "torrent", Val: st.torrent},
+			{Key: "servers_total", Val: len(links)}, {Key: "servers_ok", Val: okN}, {Key: "ips", Val: ips},
+		})
+	}
+	return out, nil
+}
+
+func (s *Sub) deleteDevice(d *deviceRow) jsjson.Object {
+	s.reconcileAll(s.forgetDeviceTx(d))
+	return jsjson.Object{{Key: "success", Val: true}, {Key: "id", Val: d.ID}}
+}
+
+func (s *Sub) rekeyDevice(d *deviceRow) {
+	s.a.db.Exec("UPDATE devices SET rekey_requested = 1 WHERE id = ? OR master_id = ?", d.ID, -1)
+}
+
+// rotatePsk — новый PSK на каждом сервере; недоступные получат его, когда появятся.
+func (s *Sub) rotatePsk(d *deviceRow) jsjson.Object {
+	s.a.db.Exec("UPDATE device_peers SET psk_pending = 1 WHERE device_id = ? AND peer_pub IS NOT NULL", d.ID)
+	var ids []int
+	for _, l := range s.linksOf(s.a.db, d.ID) {
+		ids = append(ids, l.ServerID)
+	}
+	s.reconcileAll(ids)
+	pending := 0
+	for _, l := range s.linksOf(s.a.db, d.ID) {
+		if l.PSKPending == 1 {
+			pending++
+		}
+	}
+	return jsjson.Object{{Key: "id", Val: d.ID}, {Key: "pending", Val: pending}}
+}
+
+func idObj(id int64) jsjson.Object { return jsjson.Object{{Key: "id", Val: id}} }
+
+func merge(a, b jsjson.Object) jsjson.Object {
+	out := append(jsjson.Object{}, a...)
+	for _, kv := range b {
+		replaced := false
+		for i := range out {
+			if out[i].Key == kv.Key {
+				out[i].Val, replaced = kv.Val, true
+			}
+		}
+		if !replaced {
+			out = append(out, kv)
+		}
+	}
+	return out
+}
+
+// ── Роуты панели (/ui/masterkeys, /ui/devices) ──────────────────────────────
+
+func (s *Sub) masterKeysRouter() *Router {
+	rt := newRouter()
+	auditOff := fail(409, "Аудит выключен на этой панели")
+	master := func(c *Ctx) (*masterRow, error) { return s.masterFor(s.masterIDOf(c.Params["id"]), nil) }
+
+	rt.Get("/", func(c *Ctx) bool {
+		return c.JSON(200, jsjson.Object{{Key: "enabled", Val: s.key() != nil}, {Key: "tls", Val: s.tlsPin != nil}, {Key: "keys", Val: s.listMasters(nil)}})
+	})
+	// Аудит серверов (только core): отчёт, внеочередной проход, ручная очистка, настройки.
+	rt.Get("/audit", func(c *Ctx) bool { return c.JSON(200, s.auditState()) })
+	rt.Post("/audit", aw(func(c *Ctx) (int, any, error) {
+		if !s.auditOn {
+			return 0, nil, auditOff
+		}
+		s.auditAll(false)
+		return 200, s.auditState(), nil
+	}))
+	rt.Post("/audit/clean", aw(func(c *Ctx) (int, any, error) {
+		if !s.auditOn {
+			return 0, nil, auditOff
+		}
+		s.cleanNow()
+		return 200, s.auditState(), nil
+	}))
+	rt.Put("/audit/settings", aw(func(c *Ctx) (int, any, error) {
+		if !s.auditOn {
+			return 0, nil, auditOff
+		}
+		b := c.Obj()
+		s.auditMu.Lock()
+		next := s.auditSettings
+		s.auditMu.Unlock()
+		if v, has := b.Get("clean"); has {
+			bv, ok := v.(bool)
+			if !ok {
+				return 0, nil, fail(400, "clean: true или false")
+			}
+			next.Clean = bv
+		}
+		if v, has := b.Get("every_h"); has {
+			if !isInt(v) || v.(float64) < 1 || v.(float64) > 168 {
+				return 0, nil, fail(400, "Период: от 1 до 168 часов")
+			}
+			next.EveryH = int(v.(float64))
+		}
+		if v, has := b.Get("max"); has {
+			if !isInt(v) || v.(float64) < 1 || v.(float64) > 1000 {
+				return 0, nil, fail(400, "Предел: от 1 до 1000")
+			}
+			next.Max = int(v.(float64))
+		}
+		s.auditMu.Lock()
+		s.auditSettings = next
+		s.metaSet("audit_settings", next.json())
+		s.auditMu.Unlock()
+		return 200, s.auditState(), nil
+	}))
+	rt.Post("/", aw(func(c *Ctx) (int, any, error) {
+		out, err := s.createMaster(c.Body, nil)
+		return 201, out, err
+	}))
+	rt.Patch("/:id", aw(func(c *Ctx) (int, any, error) {
+		m, err := master(c)
+		if err != nil {
+			return 0, nil, err
+		}
+		out, err := s.updateMaster(m, c.Body, nil)
+		return 200, out, err
+	}))
+	rt.Post("/:id/rotate", aw(func(c *Ctx) (int, any, error) {
+		m, err := master(c)
+		if err != nil {
+			return 0, nil, err
+		}
+		s.rotateMaster(m)
+		return 200, idObj(m.ID), nil
+	}))
+	rt.Post("/:id/rekey", aw(func(c *Ctx) (int, any, error) {
+		m, err := master(c)
+		if err != nil {
+			return 0, nil, err
+		}
+		s.rekeyMaster(m)
+		return 200, idObj(m.ID), nil
+	}))
+	rt.Delete("/:id", aw(func(c *Ctx) (int, any, error) {
+		m, err := master(c)
+		if err != nil {
+			return 0, nil, err
+		}
+		return 200, s.deleteMaster(m), nil
+	}))
+	rt.Get("/:id/link", aw(func(c *Ctx) (int, any, error) {
+		m, err := master(c)
+		if err != nil {
+			return 0, nil, err
+		}
+		out, err := s.linkOf(m, c)
+		return 200, out, err
+	}))
+	rt.Get("/:id/devices", aw(func(c *Ctx) (int, any, error) {
+		m, err := master(c)
+		if err != nil {
+			return 0, nil, err
+		}
+		list, err := s.masterDevices(m)
+		return 200, jsjson.Object{{Key: "devices", Val: list}}, err
+	}))
+	return rt
+}
+
+func (s *Sub) devicesRouter() *Router {
+	rt := newRouter()
+	dev := func(c *Ctx) (*deviceRow, error) { return s.deviceFor(idOf(c.Params["id"]), nil) }
+	rt.Delete("/:id", aw(func(c *Ctx) (int, any, error) {
+		d, err := dev(c)
+		if err != nil {
+			return 0, nil, err
+		}
+		return 200, s.deleteDevice(d), nil
+	}))
+	rt.Post("/:id/rekey", aw(func(c *Ctx) (int, any, error) {
+		d, err := dev(c)
+		if err != nil {
+			return 0, nil, err
+		}
+		s.rekeyDevice(d)
+		return 200, idObj(d.ID), nil
+	}))
+	rt.Post("/:id/psk", aw(func(c *Ctx) (int, any, error) {
+		d, err := dev(c)
+		if err != nil {
+			return 0, nil, err
+		}
+		return 200, s.rotatePsk(d), nil
+	}))
+	return rt
+}
+
+// ── Внешний API: /api/v1/masterkeys (ключ awgk_) ────────────────────────────
+// scopeOf — набор серверов API-ключа запроса. Устройства — вложенными путями, чтобы
+// область проверялась через их мастер-ключ.
+func (s *Sub) apiRouter(scopeOf func(c *Ctx) []int) *Router {
+	rt := newRouter()
+	scope := func(c *Ctx) []int {
+		if sc := scopeOf(c); sc != nil {
+			return sc
+		}
+		return []int{}
+	}
+	master := func(c *Ctx) (*masterRow, error) { return s.masterFor(s.masterIDOf(c.Params["id"]), scope(c)) }
+	device := func(c *Ctx) (*deviceRow, error) {
+		m, err := master(c)
+		if err != nil {
+			return nil, err
+		}
+		return s.deviceFor(idOf(c.Params["device"]), m)
+	}
+	withLink := func(c *Ctx, m *masterRow, base jsjson.Object) (jsjson.Object, error) {
+		l, err := s.linkOf(m, c)
+		if err != nil {
+			return nil, err
+		}
+		return merge(base, l), nil
+	}
+
+	rt.Get("/", aw(func(c *Ctx) (int, any, error) {
+		return 200, jsjson.Object{{Key: "keys", Val: s.listMasters(scope(c))}}, nil
+	}))
+	rt.Post("/", aw(func(c *Ctx) (int, any, error) {
+		if p := s.linkProblem(c); p != "" { // без ссылки ключ внешней программе бесполезен
+			return 0, nil, fail(503, p)
+		}
+		out, err := s.createMaster(c.Body, scope(c))
+		if err != nil {
+			return 0, nil, err
+		}
+		m, err := s.masterFor(int64(out.Get2("id").(int64)), nil)
+		if err != nil {
+			return 0, nil, err
+		}
+		res, err := withLink(c, m, out)
+		return 201, res, err
+	}))
+	rt.Get("/:id", aw(func(c *Ctx) (int, any, error) {
+		m, err := master(c)
+		if err != nil {
+			return 0, nil, err
+		}
+		// devices — счётчик, как в списке; сами устройства — в device_list.
+		out := s.masterOutByID(m.ID)
+		if s.linkProblem(c) != "" {
+			out = merge(out, jsjson.Object{{Key: "link", Val: nil}, {Key: "tls", Val: s.tlsPin != nil}})
+		} else if out, err = withLink(c, m, out); err != nil {
+			return 0, nil, err
+		}
+		list, err := s.masterDevices(m)
+		if err != nil {
+			return 0, nil, err
+		}
+		return 200, merge(out, jsjson.Object{{Key: "device_list", Val: list}}), nil
+	}))
+	rt.Patch("/:id", aw(func(c *Ctx) (int, any, error) {
+		m, err := master(c)
+		if err != nil {
+			return 0, nil, err
+		}
+		out, err := s.updateMaster(m, c.Body, scope(c))
+		return 200, out, err
+	}))
+	rt.Post("/:id/rotate", aw(func(c *Ctx) (int, any, error) {
+		m, err := master(c)
+		if err != nil {
+			return 0, nil, err
+		}
+		s.rotateMaster(m)
+		m2, err := s.masterFor(m.ID, nil)
+		if err != nil {
+			return 0, nil, err
+		}
+		out, err := withLink(c, m2, idObj(m.ID))
+		return 200, out, err
+	}))
+	rt.Post("/:id/rekey", aw(func(c *Ctx) (int, any, error) {
+		m, err := master(c)
+		if err != nil {
+			return 0, nil, err
+		}
+		s.rekeyMaster(m)
+		return 200, idObj(m.ID), nil
+	}))
+	rt.Delete("/:id", aw(func(c *Ctx) (int, any, error) {
+		m, err := master(c)
+		if err != nil {
+			return 0, nil, err
+		}
+		return 200, s.deleteMaster(m), nil
+	}))
+	rt.Get("/:id/devices", aw(func(c *Ctx) (int, any, error) {
+		m, err := master(c)
+		if err != nil {
+			return 0, nil, err
+		}
+		list, err := s.masterDevices(m)
+		return 200, jsjson.Object{{Key: "devices", Val: list}}, err
+	}))
+	rt.Delete("/:id/devices/:device", aw(func(c *Ctx) (int, any, error) {
+		d, err := device(c)
+		if err != nil {
+			return 0, nil, err
+		}
+		return 200, s.deleteDevice(d), nil
+	}))
+	rt.Post("/:id/devices/:device/rekey", aw(func(c *Ctx) (int, any, error) {
+		d, err := device(c)
+		if err != nil {
+			return 0, nil, err
+		}
+		s.rekeyDevice(d)
+		return 200, idObj(d.ID), nil
+	}))
+	rt.Post("/:id/devices/:device/psk", aw(func(c *Ctx) (int, any, error) {
+		d, err := device(c)
+		if err != nil {
+			return 0, nil, err
+		}
+		return 200, s.rotatePsk(d), nil
+	}))
+	return rt
+}
+
+// ── Удаление сервера из реестра ─────────────────────────────────────────────
+
+// beforeServerDelete — пока сервером пользуется живой мастер-ключ — нельзя. Иначе сперва
+// сводим его (пиры панели снимутся) — после удаления до него уже не дотянуться. Не вышло
+// (нода не в сети) — удалять только с force.
+func (s *Sub) beforeServerDelete(id int, force bool) *deleteVeto {
+	live := strs(s.a.db, "SELECT m.label FROM master_servers s JOIN master_keys m ON m.id = s.master_id WHERE s.server_id = ? AND m.revoked_at IS NULL", id)
+	if len(live) > 0 {
+		return &deleteVeto{Error: "Сервер в мастер-ключах: " + strings.Join(live, ", ") + " — сначала уберите его оттуда"}
+	}
+	if s.a.nodes.IsOnline(id) {
+		s.reconcile(id)
+	}
+	waiting := strs(s.a.db, "SELECT m.label FROM master_servers s JOIN master_keys m ON m.id = s.master_id WHERE s.server_id = ? AND m.revoked_at IS NOT NULL", id)
+	tombs := s.tombCount(id)
+	if len(waiting) == 0 && tombs == 0 || force {
+		return nil
+	}
+	msg := "Сервер не подтвердил, что снял пиров"
+	if len(waiting) > 0 {
+		msg += " удалённых мастер-ключей (" + strings.Join(waiting, ", ") + ")"
+	}
+	msg += ". Дождитесь, пока он выйдет на связь, или удалите принудительно — тогда пиры могут остаться на нём (снять: awg-ctrl peers drop)"
+	return &deleteVeto{Error: msg, Forcible: true}
+}
+
+func (s *Sub) afterServerDelete(id int) {
+	s.a.db.Exec("DELETE FROM master_servers WHERE server_id = ?", id)
+	s.a.db.Exec("DELETE FROM master_keys WHERE revoked_at IS NOT NULL AND id NOT IN (SELECT master_id FROM master_servers)")
+}

internal/ui/web.go

@@ -0,0 +1,313 @@
+package ui
+
+// Минимальный роутер с поведением Express 4, на которое опирается фронтенд и внешние клиенты:
+//   - тело разбирает express.json() до маршрутизации и для всех путей: без тела или не JSON —
+//     пустой объект {}, битый JSON / не объект и не массив — HTML 400, больше лимита — HTML 413;
+//   - пути без учёта регистра и с необязательным «/» в конце; :param декодируется;
+//   - use(prefix) совпадает по границе сегмента; первое подходящее объявление выигрывает;
+//   - неизвестный путь — HTML 404 «Cannot METHOD /path», как finalhandler.
+
+import (
+	"fmt"
+	"html"
+	"io"
+	"mime"
+	"net"
+	"net/http"
+	"net/url"
+	"strings"
+	"unicode"
+
+	"github.com/maeneko/forgetting/internal/jsjson"
+)
+
+type Ctx struct {
+	W       http.ResponseWriter
+	R       *http.Request
+	Params  map[string]string
+	Body    any    // jsjson.Object, []any; без тела — пустой Object
+	RawBody []byte // как пришло (для подписи /sub/v1)
+	Path    string // путь внутри смонтированного use(prefix), как req.path в под-роутере
+
+	// Внешний API: ключ запроса, его серверы и выбранный сервер.
+	apiKey   *apiKeyRow
+	servers  []int
+	serverID int
+	device   *deviceRow
+}
+
+// handler возвращает false, если ответ уже отправлен и цепочка дальше не идёт.
+type handler func(c *Ctx) bool
+
+type route struct {
+	method string // "" — любой (use)
+	prefix bool   // use(): совпадение по префиксу
+	segs   []string
+	hs     []handler
+}
+
+type Router struct {
+	routes []route
+	// notFound — ответ, если ничего не совпало (у /sub/v1 он подписанный).
+	notFound func(c *Ctx)
+	// badBody — ответ на неразобранное тело (у /sub/v1 подписанный 400).
+	badBody   func(w http.ResponseWriter, r *http.Request, status int, msg string)
+	bodyLimit int64
+}
+
+func newRouter() *Router { return &Router{bodyLimit: 100 * 1024} }
+
+func splitPath(p string) []string {
+	p = strings.Trim(p, "/")
+	if p == "" {
+		return nil
+	}
+	return strings.Split(p, "/")
+}
+
+func (rt *Router) add(method string, prefix bool, pattern string, hs ...handler) {
+	rt.routes = append(rt.routes, route{method: method, prefix: prefix, segs: splitPath(pattern), hs: hs})
+}
+
+func (rt *Router) Get(p string, hs ...handler)    { rt.add("GET", false, p, hs...) }
+func (rt *Router) Post(p string, hs ...handler)   { rt.add("POST", false, p, hs...) }
+func (rt *Router) Put(p string, hs ...handler)    { rt.add("PUT", false, p, hs...) }
+func (rt *Router) Patch(p string, hs ...handler)  { rt.add("PATCH", false, p, hs...) }
+func (rt *Router) Delete(p string, hs ...handler) { rt.add("DELETE", false, p, hs...) }
+func (rt *Router) Use(p string, hs ...handler)    { rt.add("", true, p, hs...) }
+
+// Mount — app.use(prefix, mw..., router): маршруты под-роутера с префиксом и общими mw.
+func (rt *Router) Mount(prefix string, sub *Router, mw ...handler) {
+	pre := splitPath(prefix)
+	for _, r := range sub.routes {
+		segs := append(append([]string{}, pre...), r.segs...)
+		rt.routes = append(rt.routes, route{method: r.method, prefix: r.prefix, segs: segs, hs: append(append([]handler{}, mw...), r.hs...)})
+	}
+}
+
+// errDecode — %-последовательность в параметре не декодируется (Express: 400 URIError).
+type errDecode struct{}
+
+func match(r route, method string, segs []string) (map[string]string, int, error) {
+	if r.method != "" && r.method != method && !(r.method == "GET" && method == "HEAD") {
+		return nil, 0, nil
+	}
+	if len(segs) < len(r.segs) || !r.prefix && len(segs) != len(r.segs) {
+		return nil, 0, nil
+	}
+	params := map[string]string{}
+	for i, p := range r.segs {
+		if strings.HasPrefix(p, ":") {
+			v, err := url.PathUnescape(segs[i])
+			if err != nil {
+				return nil, 0, fmt.Errorf("URIError: Failed to decode param '%s'", segs[i])
+			}
+			params[p[1:]] = v
+		} else if !strings.EqualFold(p, segs[i]) {
+			return nil, 0, nil
+		}
+	}
+	return params, len(r.segs), nil
+}
+
+func writeJSON(w http.ResponseWriter, status int, v any) {
+	b, err := jsjson.Marshal(v)
+	if err != nil {
+		status, b = 500, []byte(`{"error":"Internal server error"}`)
+	}
+	w.Header().Set("Content-Type", "application/json; charset=utf-8")
+	w.WriteHeader(status)
+	w.Write(b)
+}
+
+func writeHTMLError(w http.ResponseWriter, status int, text string) {
+	w.Header().Set("Content-Type", "text/html; charset=utf-8")
+	w.Header().Set("Content-Security-Policy", "default-src 'none'")
+	w.Header().Set("X-Content-Type-Options", "nosniff")
+	w.WriteHeader(status)
+	fmt.Fprintf(w, "<!DOCTYPE html>\n<html lang=\"en\">\n<head>\n<meta charset=\"utf-8\">\n<title>Error</title>\n</head>\n<body>\n<pre>%s</pre>\n</body>\n</html>\n", html.EscapeString(text))
+}
+
+// readBody — express.json({limit}): только application/json, объект или массив.
+func readBody(r *http.Request, limit int64) (body any, raw []byte, status int, msg string) {
+	empty := jsjson.Object{}
+	mt, _, _ := mime.ParseMediaType(r.Header.Get("Content-Type"))
+	if mt != "application/json" || r.Body == nil || r.Body == http.NoBody {
+		return empty, nil, 0, ""
+	}
+	if r.ContentLength > limit {
+		return nil, nil, 413, "PayloadTooLargeError: request entity too large"
+	}
+	raw, err := io.ReadAll(io.LimitReader(r.Body, limit+1))
+	if err != nil {
+		return nil, nil, 400, "BadRequestError: request aborted"
+	}
+	if int64(len(raw)) > limit {
+		return nil, nil, 413, "PayloadTooLargeError: request entity too large"
+	}
+	trimmed := strings.TrimLeftFunc(string(raw), unicode.IsSpace)
+	if trimmed == "" {
+		return empty, raw, 0, ""
+	}
+	if trimmed[0] != '{' && trimmed[0] != '[' {
+		return nil, nil, 400, "SyntaxError: Unexpected token in JSON"
+	}
+	v, err := jsjson.Decode(raw)
+	if err != nil {
+		return nil, nil, 400, "SyntaxError: " + err.Error()
+	}
+	return v, raw, 0, ""
+}
+
+func (rt *Router) ServeHTTP(w http.ResponseWriter, r *http.Request) {
+	body, raw, status, msg := readBody(r, rt.bodyLimit)
+	if status != 0 {
+		if rt.badBody != nil {
+			rt.badBody(w, r, status, msg)
+		} else {
+			writeHTMLError(w, status, msg)
+		}
+		return
+	}
+	segs := splitPath(r.URL.EscapedPath())
+	c := &Ctx{W: w, R: r, Body: body, RawBody: raw}
+	for _, route := range rt.routes {
+		params, n, err := match(route, r.Method, segs)
+		if err != nil {
+			writeHTMLError(w, 400, err.Error())
+			return
+		}
+		if params == nil {
+			continue
+		}
+		c.Params, c.Path = params, "/"+strings.Join(segs[n:], "/")
+		for _, h := range route.hs {
+			if !h(c) {
+				return // ответ отправлен
+			}
+		}
+		// Все обработчики вызвали next() — ищем дальше, как Express.
+	}
+	if rt.notFound != nil {
+		rt.notFound(c)
+		return
+	}
+	writeHTMLError(w, 404, "Cannot "+r.Method+" "+r.URL.EscapedPath())
+}
+
+// ── Ответы ──────────────────────────────────────────────────────────────────
+
+func (c *Ctx) JSON(status int, v any) bool {
+	writeJSON(c.W, status, v)
+	return false
+}
+
+func errObj(msg string) jsjson.Object { return jsjson.Object{{Key: "error", Val: msg}} }
+
+func (c *Ctx) Error(status int, msg string) bool { return c.JSON(status, errObj(msg)) }
+
+func (c *Ctx) Obj() jsjson.Object {
+	o, _ := c.Body.(jsjson.Object)
+	return o
+}
+
+// remoteIP — req.socket.remoteAddress.
+func (c *Ctx) remoteIP() string {
+	host, _, err := net.SplitHostPort(c.R.RemoteAddr)
+	if err != nil {
+		return "unknown"
+	}
+	return host
+}
+
+// hostname — req.hostname в Express (trust proxy выключен): Host без порта, у IPv6 — в скобках.
+func (c *Ctx) hostname() string {
+	h := c.R.Host
+	if strings.HasPrefix(h, "[") {
+		if i := strings.Index(h, "]"); i >= 0 {
+			return h[:i+1]
+		}
+		return h
+	}
+	if i := strings.Index(h, ":"); i >= 0 {
+		return h[:i]
+	}
+	return h
+}
+
+// ── Значения из разобранного JSON (как обращение к полям в JS) ──────────────
+
+// field — v.a.b.c; чего нет — nil (undefined).
+func field(v any, keys ...string) any {
+	for _, k := range keys {
+		o, ok := v.(jsjson.Object)
+		if !ok {
+			return nil
+		}
+		v = o.Get2(k)
+	}
+	return v
+}
+
+func has(o jsjson.Object, k string) bool {
+	_, ok := o.Get(k)
+	return ok
+}
+
+func str(v any) (string, bool) {
+	s, ok := v.(string)
+	return s, ok
+}
+
+func num(v any) (float64, bool) {
+	f, ok := v.(float64)
+	return f, ok
+}
+
+// isInt — Number.isInteger.
+func isInt(v any) bool {
+	f, ok := v.(float64)
+	return ok && f == float64(int64(f)) && f >= -9007199254740991*1024 && f <= 9007199254740991*1024
+}
+
+// isSafeInt — Number.isSafeInteger.
+func isSafeInt(f float64) bool {
+	return f == float64(int64(f)) && f >= -9007199254740991 && f <= 9007199254740991
+}
+
+// numOr — `x ?? def` для числового поля.
+func numOr(v any, def float64) float64 {
+	if f, ok := v.(float64); ok {
+		return f
+	}
+	if v == nil {
+		return def
+	}
+	return def
+}
+
+func strOr(v any, def string) string {
+	if s, ok := v.(string); ok {
+		return s
+	}
+	return def
+}
+
+func truthy(v any) bool {
+	switch x := v.(type) {
+	case nil:
+		return false
+	case bool:
+		return x
+	case float64:
+		return x != 0 && x == x
+	case string:
+		return x != ""
+	}
+	return true
+}
+
+func arr(v any) []any {
+	a, _ := v.([]any)
+	return a
+}

testdata/golden/jsjson.json

@@ -0,0 +1,274 @@
+{
+ "strings": [
+  {
+   "in": "",
+   "out": "\"\""
+  },
+  {
+   "in": "plain",
+   "out": "\"plain\""
+  },
+  {
+   "in": "кириллица",
+   "out": "\"кириллица\""
+  },
+  {
+   "in": "emoji 😀",
+   "out": "\"emoji 😀\""
+  },
+  {
+   "in": "<r 2><b 0x85>",
+   "out": "\"<r 2><b 0x85>\""
+  },
+  {
+   "in": "a&b<c>d",
+   "out": "\"a&b<c>d\""
+  },
+  {
+   "in": "slash/и\\обратный",
+   "out": "\"slash/и\\\\обратный\""
+  },
+  {
+   "in": "quote\"q",
+   "out": "\"quote\\\"q\""
+  },
+  {
+   "in": "line\nbreak",
+   "out": "\"line\\nbreak\""
+  },
+  {
+   "in": "tab\tcr\r",
+   "out": "\"tab\\tcr\\r\""
+  },
+  {
+   "in": "\b\f",
+   "out": "\"\\b\\f\""
+  },
+  {
+   "in": "\u0000\u0001\u001f",
+   "out": "\"\\u0000\\u0001\\u001f\""
+  },
+  {
+   "in": "

",
+   "out": "\"

\""
+  },
+  {
+   "in": "I2 = ",
+   "out": "\"I2 = \""
+  },
+  {
+   "in": "  spaces  ",
+   "out": "\"  spaces  \""
+  },
+  {
+   "in": "ü",
+   "out": "\"ü\""
+  },
+  {
+   "in": "日本語",
+   "out": "\"日本語\""
+  }
+ ],
+ "numbers": [
+  {
+   "in": 0,
+   "out": "0",
+   "str": "0"
+  },
+  {
+   "in": 0,
+   "out": "0",
+   "str": "0"
+  },
+  {
+   "in": 1,
+   "out": "1",
+   "str": "1"
+  },
+  {
+   "in": -1,
+   "out": "-1",
+   "str": "-1"
+  },
+  {
+   "in": 1376,
+   "out": "1376",
+   "str": "1376"
+  },
+  {
+   "in": 47619,
+   "out": "47619",
+   "str": "47619"
+  },
+  {
+   "in": 0.1,
+   "out": "0.1",
+   "str": "0.1"
+  },
+  {
+   "in": 0.5,
+   "out": "0.5",
+   "str": "0.5"
+  },
+  {
+   "in": 1.5,
+   "out": "1.5",
+   "str": "1.5"
+  },
+  {
+   "in": 2.5,
+   "out": "2.5",
+   "str": "2.5"
+  },
+  {
+   "in": 100.25,
+   "out": "100.25",
+   "str": "100.25"
+  },
+  {
+   "in": 1e+21,
+   "out": "1e+21",
+   "str": "1e+21"
+  },
+  {
+   "in": 100000000000000000000,
+   "out": "100000000000000000000",
+   "str": "100000000000000000000"
+  },
+  {
+   "in": 123456789012345680000,
+   "out": "123456789012345680000",
+   "str": "123456789012345680000"
+  },
+  {
+   "in": 1e-7,
+   "out": "1e-7",
+   "str": "1e-7"
+  },
+  {
+   "in": 0.000001,
+   "out": "0.000001",
+   "str": "0.000001"
+  },
+  {
+   "in": 0.000001234,
+   "out": "0.000001234",
+   "str": "0.000001234"
+  },
+  {
+   "in": 1.7976931348623157e+308,
+   "out": "1.7976931348623157e+308",
+   "str": "1.7976931348623157e+308"
+  },
+  {
+   "in": 5e-324,
+   "out": "5e-324",
+   "str": "5e-324"
+  },
+  {
+   "in": 3.14159,
+   "out": "3.14159",
+   "str": "3.14159"
+  },
+  {
+   "in": -273.15,
+   "out": "-273.15",
+   "str": "-273.15"
+  },
+  {
+   "in": 9007199254740992,
+   "out": "9007199254740992",
+   "str": "9007199254740992"
+  },
+  {
+   "in": 9007199254740994,
+   "out": "9007199254740994",
+   "str": "9007199254740994"
+  },
+  {
+   "in": 0.30000000000000004,
+   "out": "0.30000000000000004",
+   "str": "0.30000000000000004"
+  },
+  {
+   "in": 250.5,
+   "out": "250.5",
+   "str": "250.5"
+  },
+  {
+   "in": "NaN",
+   "out": "null",
+   "str": "NaN"
+  },
+  {
+   "in": "Infinity",
+   "out": "null",
+   "str": "Infinity"
+  },
+  {
+   "in": "-Infinity",
+   "out": "null",
+   "str": "-Infinity"
+  }
+ ],
+ "objects": [
+  {
+   "in": {
+    "a": 1,
+    "b": "x",
+    "c": [
+     1,
+     2,
+     {
+      "d": null
+     }
+    ],
+    "e": true,
+    "f": false
+   },
+   "compact": "{\"a\":1,\"b\":\"x\",\"c\":[1,2,{\"d\":null}],\"e\":true,\"f\":false}",
+   "indent2": "{\n  \"a\": 1,\n  \"b\": \"x\",\n  \"c\": [\n    1,\n    2,\n    {\n      \"d\": null\n    }\n  ],\n  \"e\": true,\n  \"f\": false\n}"
+  },
+  {
+   "in": {
+    "rekey": false,
+    "endpoints": [
+     "1.2.3.4:443"
+    ],
+    "servers": [
+     {
+      "id": 0,
+      "name": "VPN & <co>
",
+      "awg": {
+       "Jc": "6",
+       "I1": "<r 2>"
+      }
+     }
+    ]
+   },
+   "compact": "{\"rekey\":false,\"endpoints\":[\"1.2.3.4:443\"],\"servers\":[{\"id\":0,\"name\":\"VPN & <co>
\",\"awg\":{\"Jc\":\"6\",\"I1\":\"<r 2>\"}}]}",
+   "indent2": "{\n  \"rekey\": false,\n  \"endpoints\": [\n    \"1.2.3.4:443\"\n  ],\n  \"servers\": [\n    {\n      \"id\": 0,\n      \"name\": \"VPN & <co>
\",\n      \"awg\": {\n        \"Jc\": \"6\",\n        \"I1\": \"<r 2>\"\n      }\n    }\n  ]\n}"
+  },
+  {
+   "in": {
+    "empty": {},
+    "arr": [],
+    "nested": {
+     "x": []
+    }
+   },
+   "compact": "{\"empty\":{},\"arr\":[],\"nested\":{\"x\":[]}}",
+   "indent2": "{\n  \"empty\": {},\n  \"arr\": [],\n  \"nested\": {\n    \"x\": []\n  }\n}"
+  },
+  {
+   "in": [],
+   "compact": "[]",
+   "indent2": "[]"
+  },
+  {
+   "in": {},
+   "compact": "{}",
+   "indent2": "{}"
+  }
+ ]
+}

testdata/golden/sen.json

@@ -0,0 +1,323 @@
+{
+ "sign_seed": "0b6f395ca14ac202374d5cff678b71157d0bef7e00c3045e9b80aab4ffb85276",
+ "sign_pub": "ab8432736d17c6015c3f144d4ef7f7c160454e0d6db1cd9e2e79a69e0ba955f0",
+ "crc32": [
+  {
+   "in": "",
+   "out": 0
+  },
+  {
+   "in": "a",
+   "out": 3904355907
+  },
+  {
+   "in": "hello",
+   "out": 907060870
+  },
+  {
+   "in": "кириллица",
+   "out": 2804376611
+  }
+ ],
+ "encode": [
+  {
+   "tls": false,
+   "addrs": [
+    {
+     "host": "203.0.113.7",
+     "port": 8443
+    }
+   ],
+   "secret": "e8bc163c82eee18733288c7d4ac636db",
+   "name": "Семья",
+   "out": "sen://AQABBMsAcQcg--i8FjyC7uGHMyiMfUrGNturhDJzbRfGAVw_FE1O9_fBYEVODW2xzZ4ueaaeC6lV8ArQodC10LzRjNGPnrdgwg"
+  },
+  {
+   "tls": true,
+   "addrs": [
+    {
+     "host": "vpn.example.com",
+     "port": 443
+    }
+   ],
+   "secret": "ad328846aa18b32a335816374511cac1",
+   "tlsPin": "64f46a7526a186d2346552453ae478ca51244674f5b21ba150bd483b39f7c812",
+   "name": "",
+   "out": "sen://AQEBRA92cG4uZXhhbXBsZS5jb20Bu60yiEaqGLMqM1gWN0URysGrhDJzbRfGAVw_FE1O9_fBYEVODW2xzZ4ueaaeC6lV8GT0anUmoYbSNGVSRTrkeMpRJEZ09bIboVC9SDs598gSAO9JOXk"
+  },
+  {
+   "tls": false,
+   "addrs": [
+    {
+     "host": "2001:db8::1",
+     "port": 1
+    },
+    {
+     "host": "::",
+     "port": 65535
+    },
+    {
+     "host": "fe80:0:0:1:0:0:0:1",
+     "port": 80
+    }
+   ],
+   "secret": "41242b9fae56fad4e6e77dfe33cb18d1",
+   "name": "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx",
+   "out": "sen://AQADBiABDbgAAAAAAAAAAAAAAAEAAQYAAAAAAAAAAAAAAAAAAAAA__8G_oAAAAAAAAEAAAAAAAAAAQBQQSQrn65W-tTm533-M8sY0auEMnNtF8YBXD8UTU7398FgRU4NbbHNni55pp4LqVXwQHh4eHh4eHh4eHh4eHh4eHh4eHh4eHh4eHh4eHh4eHh4eHh4eHh4eHh4eHh4eHh4eHh4eHh4eHh4eHh4eHh4eHhMjeF6"
+  },
+  {
+   "tls": false,
+   "addrs": [
+    {
+     "host": "1:2:3:4:5:6:7:8",
+     "port": 2
+    }
+   ],
+   "secret": "5b840157e7e86aef3b3fd0fc24f3add3",
+   "name": "emoji 😀 & <>",
+   "out": "sen://AQABBgABAAIAAwAEAAUABgAHAAgAAluEAVfn6GrvOz_Q_CTzrdOrhDJzbRfGAVw_FE1O9_fBYEVODW2xzZ4ueaaeC6lV8A9lbW9qaSDwn5iAICYgPD6UZmVs"
+  }
+ ],
+ "encode_errors": [
+  {
+   "tls": false,
+   "addrs": [],
+   "secret": "ca978112ca1bbdcafac231b39a23dc4d",
+   "name": "",
+   "error": "Адресов должно быть от 1 до 3"
+  },
+  {
+   "tls": false,
+   "addrs": [
+    {
+     "host": "256.1.1.1",
+     "port": 1
+    }
+   ],
+   "secret": "ca978112ca1bbdcafac231b39a23dc4d",
+   "name": "",
+   "error": "Неверный IPv4: 256.1.1.1"
+  },
+  {
+   "tls": false,
+   "addrs": [
+    {
+     "host": "1::2::3",
+     "port": 1
+    }
+   ],
+   "secret": "ca978112ca1bbdcafac231b39a23dc4d",
+   "name": "",
+   "error": "Неверный IPv6: 1::2::3"
+  },
+  {
+   "tls": false,
+   "addrs": [
+    {
+     "host": "bad_host",
+     "port": 1
+    }
+   ],
+   "secret": "ca978112ca1bbdcafac231b39a23dc4d",
+   "name": "",
+   "error": "Неверный домен: bad_host"
+  },
+  {
+   "tls": false,
+   "addrs": [
+    {
+     "host": "a.b",
+     "port": 0
+    }
+   ],
+   "secret": "ca978112ca1bbdcafac231b39a23dc4d",
+   "name": "",
+   "error": "Неверный порт: 0"
+  },
+  {
+   "tls": false,
+   "addrs": [
+    {
+     "host": "a.b",
+     "port": 1
+    }
+   ],
+   "secret": "ca978112ca1bbdcafac231b39a23dc4d",
+   "name": "яяяяяяяяяяяяяяяяяяяяяяяяяяяяяяяяя",
+   "error": "Имя: до 64 байт"
+  },
+  {
+   "tls": true,
+   "addrs": [
+    {
+     "host": "a.b",
+     "port": 1
+    }
+   ],
+   "secret": "ca978112ca1bbdcafac231b39a23dc4d",
+   "name": "",
+   "error": "tlsPin: 32 байта при TLS"
+  }
+ ],
+ "decode": [
+  {
+   "in": "sen://AQABBMsAcQcg--i8FjyC7uGHMyiMfUrGNturhDJzbRfGAVw_FE1O9_fBYEVODW2xzZ4ueaaeC6lV8ArQodC10LzRjNGPnrdgwg",
+   "tls": false,
+   "addrs": [
+    {
+     "host": "203.0.113.7",
+     "port": 8443
+    }
+   ],
+   "secret": "e8bc163c82eee18733288c7d4ac636db",
+   "signPub": "ab8432736d17c6015c3f144d4ef7f7c160454e0d6db1cd9e2e79a69e0ba955f0",
+   "tlsPin": null,
+   "name": "Семья"
+  },
+  {
+   "in": "sen://AQEBRA92cG4uZXhhbXBsZS5jb20Bu60yiEaqGLMqM1gWN0URysGrhDJzbRfGAVw_FE1O9_fBYEVODW2xzZ4ueaaeC6lV8GT0anUmoYbSNGVSRTrkeMpRJEZ09bIboVC9SDs598gSAO9JOXk",
+   "tls": true,
+   "addrs": [
+    {
+     "host": "vpn.example.com",
+     "port": 443
+    }
+   ],
+   "secret": "ad328846aa18b32a335816374511cac1",
+   "signPub": "ab8432736d17c6015c3f144d4ef7f7c160454e0d6db1cd9e2e79a69e0ba955f0",
+   "tlsPin": "64f46a7526a186d2346552453ae478ca51244674f5b21ba150bd483b39f7c812",
+   "name": ""
+  },
+  {
+   "in": "sen://AQADBiABDbgAAAAAAAAAAAAAAAEAAQYAAAAAAAAAAAAAAAAAAAAA__8G_oAAAAAAAAEAAAAAAAAAAQBQQSQrn65W-tTm533-M8sY0auEMnNtF8YBXD8UTU7398FgRU4NbbHNni55pp4LqVXwQHh4eHh4eHh4eHh4eHh4eHh4eHh4eHh4eHh4eHh4eHh4eHh4eHh4eHh4eHh4eHh4eHh4eHh4eHh4eHh4eHh4eHhMjeF6",
+   "tls": false,
+   "addrs": [
+    {
+     "host": "2001:db8::1",
+     "port": 1
+    },
+    {
+     "host": "::",
+     "port": 65535
+    },
+    {
+     "host": "fe80:0:0:1::1",
+     "port": 80
+    }
+   ],
+   "secret": "41242b9fae56fad4e6e77dfe33cb18d1",
+   "signPub": "ab8432736d17c6015c3f144d4ef7f7c160454e0d6db1cd9e2e79a69e0ba955f0",
+   "tlsPin": null,
+   "name": "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx"
+  },
+  {
+   "in": "sen://AQABBgABAAIAAwAEAAUABgAHAAgAAluEAVfn6GrvOz_Q_CTzrdOrhDJzbRfGAVw_FE1O9_fBYEVODW2xzZ4ueaaeC6lV8A9lbW9qaSDwn5iAICYgPD6UZmVs",
+   "tls": false,
+   "addrs": [
+    {
+     "host": "1:2:3:4:5:6:7:8",
+     "port": 2
+    }
+   ],
+   "secret": "5b840157e7e86aef3b3fd0fc24f3add3",
+   "signPub": "ab8432736d17c6015c3f144d4ef7f7c160454e0d6db1cd9e2e79a69e0ba955f0",
+   "tlsPin": null,
+   "name": "emoji 😀 & <>"
+  },
+  {
+   "in": "  SEN://AQABBMsAcQcg--i8FjyC7uGHMyiMfUrGNturhDJzbRfGAVw_FE1O9_fBYEVODW2xzZ4ueaaeC6lV8ArQodC10LzRjNGPnrdgwg \n",
+   "tls": false,
+   "addrs": [
+    {
+     "host": "203.0.113.7",
+     "port": 8443
+    }
+   ],
+   "secret": "e8bc163c82eee18733288c7d4ac636db",
+   "signPub": "ab8432736d17c6015c3f144d4ef7f7c160454e0d6db1cd9e2e79a69e0ba955f0",
+   "tlsPin": null,
+   "name": "Семья"
+  },
+  {
+   "in": "sen://AQEBRA92cG4uZX\nhhbXBsZS5jb20Bu60yiEaqGLMqM1gWN0URysGrhDJzbRfGAVw_FE1O9_fBYEVODW2xzZ4ueaaeC6lV8GT0anUmoYbSNGVSRTrkeMpRJEZ09bIboVC9SDs598gSAO9JOXk",
+   "tls": true,
+   "addrs": [
+    {
+     "host": "vpn.example.com",
+     "port": 443
+    }
+   ],
+   "secret": "ad328846aa18b32a335816374511cac1",
+   "signPub": "ab8432736d17c6015c3f144d4ef7f7c160454e0d6db1cd9e2e79a69e0ba955f0",
+   "tlsPin": "64f46a7526a186d2346552453ae478ca51244674f5b21ba150bd483b39f7c812",
+   "name": ""
+  },
+  {
+   "in": "http://x",
+   "error": "Ссылка должна начинаться с sen://"
+  },
+  {
+   "in": "sen://",
+   "error": "Ссылка повреждена: недопустимые символы"
+  },
+  {
+   "in": "sen://AAAA",
+   "error": "Ссылка слишком короткая"
+  },
+  {
+   "in": "sen://a+b",
+   "error": "Ссылка повреждена: недопустимые символы"
+  },
+  {
+   "in": "sen://AQABBMsAcQcg--i8FjyC7uGHMyiMfUrGNturhDJzbRfGAVw_FE1O9_fBYEVODW2xzZ4ueaaeC6lV8ArQodC10LzRjNGPnrdg",
+   "error": "Ссылка повреждена: не сошлась контрольная сумма"
+  },
+  {
+   "in": "sen://AQABBMsAcQcg--i8FjyC7uGHMyiMfUrGNturhDJzbRfGAVw_FE1O9_fBYEVODW2xzZ4ueaaeC6lV8ArQodC10LzRjNGPnrdgwA",
+   "error": "Ссылка повреждена: не сошлась контрольная сумма"
+  }
+ ],
+ "sig_string": [
+  {
+   "method": "post",
+   "path": "/sub/v1/register",
+   "ts": 1700000000,
+   "body": "{\"a\":1}",
+   "out": "POST\n/sub/v1/register\n1700000000\n015abd7f5cc57a2dd94b7590f04ad8084273905ee33ec5cebeae62276a97f862",
+   "sig": "CHqkcC2BwATFKxopbQlDvSDNKCRzAxKaynJ0SDWuj-ht2L5tFcDmIsjFL2vnKiaDuNSCr-ABbWR_uzgIj7mfCw"
+  },
+  {
+   "method": "GET",
+   "path": "/sub/v1/config",
+   "ts": 1,
+   "body": "",
+   "out": "GET\n/sub/v1/config\n1\ne3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855",
+   "sig": "9p4dzFWv-JeWYVzxxdhjeEMIz1uH_XDVAea94YwQmYTE3j9-9hGRR6mVRs9T4szHvBUExnyXXiApOXEDkd3zCQ"
+  }
+ ],
+ "sign_response": [
+  {
+   "in": {
+    "config": {
+     "rev": "ab",
+     "servers": []
+    },
+    "device": 3,
+    "ts": 5
+   },
+   "out": {
+    "body": "{\"config\":{\"rev\":\"ab\",\"servers\":[]},\"device\":3,\"ts\":5}",
+    "sig": "jcH9kAuxkvyBKJFLR-uSbaQgEh6dede75PLezg0v7yATUQojATafYKbQ8-aJAjvlHbv4G04j1eMD5owW9tQZDw"
+   }
+  },
+  {
+   "in": {
+    "error": "revoked"
+   },
+   "out": {
+    "body": "{\"error\":\"revoked\"}",
+    "sig": "Eb9F2GY-lyqk7ZxxKYHxSTl-goq7oUCYxBwguLpSw1oQmrXVFpUehQdd6_02UfjtDX1Rtth4-uf8-t4XFuciAA"
+   }
+  }
+ ]
+}

tools/diffbench/Dockerfile

@@ -0,0 +1,11 @@
+# Дифференциальный стенд: TS- и Go-версии awg-ctrl против одних и тех же заглушек.
+FROM node:20-bookworm
+RUN apt-get update -qq && apt-get install -y -qq --no-install-recommends openssl sqlite3 >/dev/null && rm -rf /var/lib/apt/lists/*
+COPY tools/diffbench/stubs/stub.mjs /opt/stub/stub.mjs
+RUN for c in awg awg-quick ip tc nft modinfo; do printf '#!/bin/sh\nexec node /opt/stub/stub.mjs %s "$@"\n' "$c" > /usr/local/bin/$c; chmod +x /usr/local/bin/$c; done
+# TS-эталон: тот же код, что в репозитории, со своими node_modules под linux
+COPY awg-ctrl/package.json /ts/awg-ctrl/package.json
+RUN cd /ts/awg-ctrl && npm install --no-audit --no-fund --loglevel=error
+COPY awg-ctrl/index.ts awg-ctrl/shaping.ts awg-ctrl/tsconfig.json /ts/awg-ctrl/
+COPY tools/diffbench/setup.sh tools/diffbench/run.sh tools/diffbench/scenario-ctrl.mjs tools/diffbench/collect.mjs /bench/
+WORKDIR /bench

tools/diffbench/collect-ui.mjs

@@ -0,0 +1,17 @@
+// Состояние после сценария awg-ui: строки ui.db и пиры/пользователи awg-ctrl.
+import fs from "fs";
+import { execSync } from "child_process";
+const out = process.argv[2];
+const t = JSON.parse(fs.readFileSync(out, "utf8"));
+const q = (db, sql) => JSON.parse(execSync(`sqlite3 -json ${db} "${sql}"`).toString() || "[]");
+const UI = "/run/bench/ui.db", CT = "/etc/amnezia/amneziawg/users.db";
+const tables = ["api_keys", "api_key_servers", "nodes", "master_keys", "master_servers", "devices", "device_peers",
+  "peer_tombstones", "server_profiles", "sub_meta", "metrics_token"];
+t.state = {
+  ui: Object.fromEntries(tables.map(x => [x, q(UI, `select * from ${x} order by rowid`)])),
+  uiSchema: execSync(`sqlite3 ${UI} .schema`).toString(),
+  ctrlUsers: q(CT, "select name, ip, key_gen from users order by rowid"),
+  ctrlPeers: q(CT, "select pub_key, ip, owner from peers order by rowid"),
+};
+fs.writeFileSync(out, JSON.stringify(t, null, 1));
+console.log("collect-ui: done");

tools/diffbench/collect.mjs

@@ -0,0 +1,20 @@
+// Состояние после сценария: conf, файлы каталога, строки баз, журнал и состояние заглушек.
+import fs from "fs";
+import { execSync } from "child_process";
+const out = process.argv[2];
+const t = JSON.parse(fs.readFileSync(out, "utf8"));
+const D = "/etc/amnezia/amneziawg";
+const q = sql => JSON.parse(execSync(`sqlite3 -json ${D}/users.db "${sql}"`).toString() || "[]");
+t.state = {
+    conf: fs.readFileSync(`${D}/awg1.conf`, "utf8"),
+    confMode: (fs.statSync(`${D}/awg1.conf`).mode & 0o777).toString(8),
+    files: fs.readdirSync(D).map(f => f.replace(/\d{4}-\d\d-\d\dT[\d-]+Z/, "<ts>")).sort(),
+    users: q("select * from users order by rowid"),
+    peers: q("select * from peers order by rowid"),
+    config: q("select * from config order by key"),
+    schema: execSync(`sqlite3 ${D}/users.db .schema`).toString(),
+    stubLog: fs.readFileSync("/var/lib/stub/log.jsonl", "utf8").split("\n").filter(Boolean).map(l => JSON.parse(l)),
+    stubState: JSON.parse(fs.readFileSync("/var/lib/stub/state.json", "utf8")),
+};
+fs.writeFileSync(out, JSON.stringify(t, null, 1));
+console.log(`collect: done`);

tools/diffbench/compare-ui.mjs

@@ -0,0 +1,61 @@
+// compare-ui.mjs <ts.json> <go.json>: расхождения двух прогонов scenario-ui. Случайное
+// маскируется (токены, ключи, uuid, ссылки, подписи, время, id панели); подписанные ответы
+// /sub/v1 раскрываются: сравнивается body, а подпись — только что она есть.
+import fs from "fs";
+const [a, b] = process.argv.slice(2).map(f => JSON.parse(fs.readFileSync(f, "utf8")));
+const panelOf = r => r.state.ui.sub_meta.find(x => x.key === "panel_id")?.value ?? "";
+const TIME_KEYS = /^(created_at|last_used|last_seen|at|ts|updated_at|join_expires|revoked_at|expires_in_at)$/;
+function mask(s, panel) {
+  if (panel) s = s.split(panel).join("<panel>");
+  return s
+    .replace(/eyJ[A-Za-z0-9_-]+\.[A-Za-z0-9_-]+\.[A-Za-z0-9_-]+/g, "<jwt>")
+    .replace(/awg[km]_[A-Za-z0-9_-]{8}(…|[A-Za-z0-9_-]{24})/g, "<token>")
+    .replace(/[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}/gi, "<uuid>")
+    .replace(/sen:\/\/[A-Za-z0-9_-]+/g, "<sen>")
+    .replace(/awgjoin:\/\/[A-Za-z0-9_-]+/g, "<join>")
+    .replace(/awg_scrape_duration_seconds [0-9.e-]+/g, "awg_scrape_duration_seconds <d>")
+    .replace(/(awg_host_[a-z_]+\{[^}]*\}) [0-9.e+-]+/g, "$1 <n>");
+}
+function norm(v, panel, key = "") {
+  if (typeof v === "string") {
+    if (key === "sig") return "<sig>";
+    if (key === "body" && v.startsWith("{")) { try { return norm(JSON.parse(v), panel); } catch {} }
+    return mask(v, panel);
+  }
+  if (typeof v === "number" && TIME_KEYS.test(key)) return "<t>";
+  if (Array.isArray(v)) return v.map(x => norm(x, panel));
+  if (v && typeof v === "object") {
+    const o = {};
+    for (const [k, x] of Object.entries(v)) {
+      if (["key_hash", "secret", "join_hash", "token_hash", "pub", "prefix"].includes(k) && x !== null) { o[k] = "<rnd>"; continue; }
+      if (k === "value" && typeof x === "string" && /^[[{]/.test(x)) { o[k] = norm(JSON.parse(x), panel); continue; }
+      o[k] = norm(x, panel, k);
+    }
+    return o;
+  }
+  return v;
+}
+const pa = panelOf(a), pb = panelOf(b);
+let diffs = 0;
+const show = (label, x, y) => {
+  const X = JSON.stringify(norm(x, pa)), Y = JSON.stringify(norm(y, pb));
+  if (X === Y) return;
+  diffs++;
+  let i = 0; while (X[i] === Y[i]) i++;
+  const from = Math.max(0, i - 120);
+  console.log(`### ${label} @${i}\n TS: …${X.slice(from, i + 300)}\n GO: …${Y.slice(from, i + 300)}`);
+};
+if (a.error || b.error) console.log("scenario error:", a.error, "|", b.error);
+const n = Math.max(a.steps.length, b.steps.length);
+for (let i = 0; i < n; i++) {
+  const s = a.steps[i] ?? {}, t = b.steps[i] ?? {};
+  // text не сравниваем: порядок ключей виден и в разобранном body (Object.entries его хранит).
+  // Стек Express в dev-режиме (NODE_ENV не задан) у Go не воспроизводится — сравниваем тип ошибки.
+  const html = x => typeof x === "string" ? x.replace(/<pre>([A-Za-z]+Error)[^<]*(<br>[\s\S]*)?<\/pre>/, "<pre>$1</pre>") : x;
+  show(`${i} ${s.name ?? t.name} ${s.method} ${s.path}`, { st: s.status, ct: s.ctype, body: html(s.body) }, { st: t.status, ct: t.ctype, body: html(t.body) });
+}
+for (const k of Object.keys(a.state.ui)) show("ui." + k, a.state.ui[k], b.state.ui[k]);
+show("uiSchema", a.state.uiSchema.replace(/\s+/g, " "), b.state.uiSchema.replace(/\s+/g, " "));
+show("ctrlUsers", a.state.ctrlUsers, b.state.ctrlUsers);
+show("ctrlPeers", a.state.ctrlPeers, b.state.ctrlPeers);
+console.log(diffs ? `${diffs} differences` : "IDENTICAL");

tools/diffbench/compare.mjs

@@ -0,0 +1,31 @@
+// compare.mjs <ts.json> <go.json>: расхождения двух прогонов стенда. vpn:// раскрываются
+// (сжатие у Node и Go разное), время маскируется.
+import fs from "fs"; import zlib from "zlib";
+const [a, b] = process.argv.slice(2).map(f => JSON.parse(fs.readFileSync(f, "utf8")));
+const dec = s => { try { const buf = Buffer.from(s.slice(6), "base64url"); return "vpn<" + zlib.inflateSync(buf.subarray(4)).toString() + ">"; } catch (e) { return "vpn<undecodable " + e.message + ">"; } };
+const norm = v => {
+  if (typeof v === "string") {
+    let s = v.replace(/vpn:\/\/[A-Za-z0-9_-]+/g, dec);
+    s = s.replace(/\d{4}-\d\d-\d\dT[\d:.-]+Z/g, "<ts>").replace(/"(created_at|lastHandshake|ts|time|uptime|generated_at)":\d+/g, '"$1":<n>');
+    return s;
+  }
+  if (Array.isArray(v)) return v.map(norm);
+  if (v && typeof v === "object") return Object.fromEntries(Object.entries(v).map(([k, x]) => [k, /^(created_at|lastHandshake|ts|uptime)$/.test(k) && typeof x === "number" ? "<n>" : norm(x)]));
+  return v;
+};
+// Известный шум: живые цифры хоста (порядок ключей сохраняем), стек Express в dev-режиме,
+// порядок вызовов из параллельных фоновых задач, отступы в CREATE TABLE.
+const host = h => h && { cpu: Object.keys(h.cpu), cores: h.cores, load: h.load?.length, mem: Object.keys(h.mem) };
+for (const r of [a, b]) {
+  for (const s of r.steps) {
+    if (s.body?.host) { s.body.host = host(s.body.host); s.text = JSON.stringify(s.body); }
+    if (s.ctype === "text/html") s.body = s.body.replace(/<pre>([A-Za-z]+Error)[^<]*(<br>[\s\S]*)?<\/pre>/, "<pre>$1</pre>");
+  }
+  r.state.stubLog = r.state.stubLog.map(e => JSON.stringify(e).replace(/awg_(sync|psk)_\d+/g, "awg_$1_N")).sort();
+  r.state.schema = r.state.schema.replace(/\s+/g, " ");
+}
+let diffs = 0;
+const show = (label, x, y) => { const X = JSON.stringify(norm(x)), Y = JSON.stringify(norm(y)); if (X !== Y) { diffs++; let i = 0; while (X[i] === Y[i]) i++; const from = Math.max(0, i - 150); console.log(`### ${label} @${i}\n TS: …${X.slice(from, i + 350)}\n GO: …${Y.slice(from, i + 350)}`); } };
+a.steps.forEach((s, i) => { const t = b.steps[i]; show(`${i} ${s.name}`, { st: s.status, ct: s.ctype, body: s.body, text: s.text }, { st: t.status, ct: t.ctype, body: t.body, text: t.text }); });
+for (const k of Object.keys(a.state)) show("state." + k, a.state[k], b.state[k]);
+console.log(diffs ? `${diffs} differences` : "IDENTICAL");

tools/diffbench/local-ui.sh

@@ -0,0 +1,46 @@
+#!/bin/sh
+# local-ui.sh <ts|go> <имя-прогона> — дифференциальный прогон awg-ui без Docker: awg-ctrl (Go,
+# на заглушках, сверен с TS отдельно) + панель нужной реализации + нода из Go-агента на тот же
+# awg-ctrl. Как и local.sh — только для одноразовой машины: пересоздаёт /etc/amnezia.
+# Нужны node 20+, sqlite3, openssl, go и `npm install` в awg-ui/ (и собранный awg-ui/dist).
+set -e
+IMPL="$1"; NAME="$2"
+B=$(cd "$(dirname "$0")" && pwd); ROOT=$(cd "$B/../.." && pwd)
+BENCH=/var/lib/uibench
+mkdir -p "$B/bin/stubs" "$B/out" "$BENCH"
+for c in awg awg-quick ip tc nft modinfo; do
+  printf '#!/bin/sh\nexec node %s %s "$@"\n' "$B/stubs/stub.mjs" "$c" > "$B/bin/stubs/$c"; chmod +x "$B/bin/stubs/$c"
+done
+export PATH="$B/bin/stubs:$PATH"
+(cd "$ROOT" && go build ${RACE:+-race} -o "$B/bin/awg-control" ./cmd/awg-control)  # RACE=1 — с детектором гонок
+# Ключи стенда — одни на все прогоны: подпись sen://, сертификат хаба нод.
+[ -f "$BENCH/sub_sign.key" ] || openssl genpkey -algorithm ed25519 -out "$BENCH/sub_sign.key" 2>/dev/null
+[ -f "$BENCH/node_tls.key" ] || openssl req -x509 -newkey ec -pkeyopt ec_paramgen_curve:prime256v1 -nodes \
+  -keyout "$BENCH/node_tls.key" -out "$BENCH/node_tls.crt" -days 3650 -subj /CN=awg-node 2>/dev/null
+sh "$B/setup.sh"
+
+PORT=3005 SERVER_IP=203.0.113.7 SERVER_PORT=47619 SERVER_NAME=VPN \
+  INTERNAL_AUTH_PUB_FILE=/etc/amnezia/amneziawg/internal_auth_public.key SHAPE_SAMPLE_S=3600 AWG_CLI=/nonexistent/awg-ctrl \
+  sh -c 'cd /tmp && exec "$0" ctrl' "$B/bin/awg-control" > /run/bench/ctrl.log 2>&1 &
+CTRL=$!
+i=0; until curl -s -o /dev/null http://127.0.0.1:3005/health; do i=$((i+1)); [ $i -gt 150 ] && { cat /run/bench/ctrl.log; kill $CTRL; exit 1; }; sleep 0.1; done
+
+export PORT=8080 UI_USER=admin UI_PASS=benchpass JWT_SECRET=benchsecret UI_DB_FILE=/run/bench/ui.db AWGCTRL_PORT=3005 \
+  INTERNAL_AUTH_KEY_FILE=/etc/amnezia/amneziawg/internal_auth_private.key \
+  SUB_PORT=8443 SUB_TLS=off SUB_SIGN_KEY_FILE="$BENCH/sub_sign.key" SUB_HOST=sub.example.com \
+  NODE_PORT=8444 NODE_TLS_KEY_FILE="$BENCH/node_tls.key" NODE_TLS_CERT_FILE="$BENCH/node_tls.crt" \
+  BRAND=Bench CHANNEL=Beta VERSION=0.0.0-bench MONITOR_HASH_FILE="$BENCH/none" PROM_URL=http://127.0.0.1:9 \
+  METRICS_PEERS=on AUDIT=on LOCAL_NODE=on
+cd "$ROOT/awg-ui"
+if [ "$IMPL" = "ts" ]; then node node_modules/.bin/tsx server.ts > /run/bench/ui.log 2>&1 &
+else "$B/bin/awg-control" ui > /run/bench/ui.log 2>&1 &
+fi
+UIPID=$!
+i=0; until curl -s -o /dev/null http://127.0.0.1:8080/ui/brand; do i=$((i+1)); [ $i -gt 200 ] && { cat /run/bench/ui.log; kill $UIPID $CTRL; exit 1; }; sleep 0.1; done
+sleep 1
+
+AGENT_BIN="$B/bin/awg-control" BENCH_DIR="$BENCH" "$ROOT/awg-ui/node_modules/.bin/tsx" "$B/scenario-ui.ts" "$B/out/$NAME.json" || true
+sleep 2
+kill $UIPID $CTRL 2>/dev/null || true; wait $UIPID $CTRL 2>/dev/null || true
+node "$B/collect-ui.mjs" "$B/out/$NAME.json"
+cp /run/bench/ui.log "$B/out/$NAME.ui.log"; cp /run/bench/ctrl.log "$B/out/$NAME.ctrl.log"

tools/diffbench/local.sh

@@ -0,0 +1,33 @@
+#!/bin/sh
+# local.sh <ts|go> <имя-прогона> — тот же прогон, что run.sh, но без Docker: на одноразовой
+# машине (CI-раннер, облачная песочница). Заглушки кладутся в свой каталог и попадают только
+# в PATH этого прогона; ВНИМАНИЕ: setup.sh пересоздаёт /etc/amnezia — не запускать на сервере.
+# Нужны node 20+, sqlite3, openssl, go; npm install в awg-ctrl/ делается при первом запуске.
+# Окружение то же: GEN, WITH_I1, S4, STUB_MODULE. Результат — tools/diffbench/out/<имя>.json.
+set -e
+IMPL="$1"; NAME="$2"
+B=$(cd "$(dirname "$0")" && pwd); ROOT=$(cd "$B/../.." && pwd)
+mkdir -p "$B/bin/stubs" "$B/out"
+for c in awg awg-quick ip tc nft modinfo; do
+  printf '#!/bin/sh\nexec node %s %s "$@"\n' "$B/stubs/stub.mjs" "$c" > "$B/bin/stubs/$c"; chmod +x "$B/bin/stubs/$c"
+done
+export PATH="$B/bin/stubs:$PATH"
+if [ "$IMPL" = "go" ]; then (cd "$ROOT" && go build -o "$B/bin/awg-control" ./cmd/awg-control)
+elif [ ! -d "$ROOT/awg-ctrl/node_modules" ]; then (cd "$ROOT/awg-ctrl" && npm install --no-audit --no-fund --loglevel=error --no-package-lock); fi
+sh "$B/setup.sh"
+export PORT=3005 SERVER_IP=203.0.113.7 SERVER_PORT=47619 SERVER_NAME=VPN \
+       INTERNAL_AUTH_PUB_FILE=/etc/amnezia/amneziawg/internal_auth_public.key \
+       SHAPE_SAMPLE_S=3600 AWG_CLI=/nonexistent/awg-ctrl
+cd "$ROOT/awg-ctrl"
+if [ "$IMPL" = "ts" ]; then node node_modules/.bin/tsx index.ts > /run/bench/ctrl.log 2>&1 &
+else "$B/bin/awg-control" ctrl > /run/bench/ctrl.log 2>&1 &
+fi
+PID=$!
+i=0; until curl -s -o /dev/null http://127.0.0.1:3005/health; do i=$((i+1)); [ $i -gt 150 ] && { cat /run/bench/ctrl.log; kill $PID; exit 1; }; sleep 0.1; done
+sleep 1
+cd "$B"
+node scenario-ctrl.mjs "$B/out/$NAME.json"
+sleep 3
+kill $PID 2>/dev/null || true; wait $PID 2>/dev/null || true
+node collect.mjs "$B/out/$NAME.json"
+cp /run/bench/ctrl.log "$B/out/$NAME.log"

tools/diffbench/run.sh

@@ -0,0 +1,24 @@
+#!/bin/sh
+# run.sh <ts|go> <имя-прогона>; окружение: GEN, WITH_I1, STUB_MODULE
+set -e
+IMPL="$1"; NAME="$2"
+./setup.sh
+export PORT=3005 SERVER_IP=203.0.113.7 SERVER_PORT=47619 SERVER_NAME=VPN \
+       INTERNAL_AUTH_PUB_FILE=/etc/amnezia/amneziawg/internal_auth_public.key \
+       SHAPE_SAMPLE_S=3600 AWG_CLI=/nonexistent/awg-ctrl
+cd /ts/awg-ctrl
+if [ "$IMPL" = "ts" ]; then
+  node node_modules/.bin/tsx index.ts > /run/bench/ctrl.log 2>&1 &
+else
+  /go/awg-control ctrl > /run/bench/ctrl.log 2>&1 &
+fi
+PID=$!
+i=0; until curl -s -o /dev/null http://127.0.0.1:3005/health; do i=$((i+1)); [ $i -gt 100 ] && { cat /run/bench/ctrl.log; exit 1; }; sleep 0.1; done
+sleep 1   # стартовый apply шейпинга асинхронный — даём ему отработать до сценария
+cd /bench
+node scenario-ctrl.mjs "/out/$NAME.json"
+# фоновый apply шейпинга после restart/upgrade должен доработать, иначе журнал заглушек обрежется
+sleep 3
+kill $PID 2>/dev/null || true; wait $PID 2>/dev/null || true
+node collect.mjs "/out/$NAME.json"
+cp /run/bench/ctrl.log "/out/$NAME.log"

tools/diffbench/scenario-ctrl.mjs

@@ -0,0 +1,112 @@
+// Сценарий для awg-ctrl: одинаковая последовательность запросов к любой реализации.
+// Пишет транскрипт (запрос → статус, тип, тело) в JSON; collect.mjs дописывает состояние.
+import fs from "fs";
+import crypto from "crypto";
+import { execSync } from "child_process";
+
+const BASE = "http://127.0.0.1:3005";
+const KEY = crypto.createPrivateKey(fs.readFileSync("/etc/amnezia/amneziawg/internal_auth_private.key"));
+const out = process.argv[2];
+
+function token(iss = "bench") {
+    const h = Buffer.from(JSON.stringify({ alg: "EdDSA", typ: "JWT" })).toString("base64url");
+    const t = Math.floor(Date.now() / 1000);
+    const p = Buffer.from(JSON.stringify({ iss, iat: t, exp: t + 60 })).toString("base64url");
+    return `${h}.${p}.${crypto.sign(null, Buffer.from(`${h}.${p}`), KEY).toString("base64url")}`;
+}
+const key = s => crypto.createHash("sha256").update(s).digest("base64");
+const url64 = k => Buffer.from(k, "base64").toString("base64url");
+const P1 = key("dev1"), P2 = key("dev2"), P3 = key("dev3"), GHOST = key("ghost");
+
+const steps = [];
+async function call(name, method, path, body, { auth = true, raw, headers = {} } = {}) {
+    const h = { ...headers };
+    if (auth) h.authorization = `Bearer ${typeof auth === "string" ? auth : token()}`;
+    let data;
+    if (raw !== undefined) { h["content-type"] = "application/json"; data = raw; }
+    else if (body !== undefined) { h["content-type"] = "application/json"; data = JSON.stringify(body); }
+    const r = await fetch(BASE + path, { method, headers: h, body: data });
+    const ctype = (r.headers.get("content-type") ?? "").split(";")[0];
+    const text = await r.text();
+    let parsed = text;
+    if (ctype === "application/json") { try { parsed = JSON.parse(text); } catch {} }
+    steps.push({ name, method, path, status: r.status, ctype, body: parsed, text: ctype === "application/json" ? text : undefined });
+    return parsed;
+}
+
+const gen = process.env.GEN ?? "2";
+
+await call("health", "GET", "/health", undefined, { auth: false });
+await call("no token", "GET", "/api/users", undefined, { auth: false });
+await call("bad token", "GET", "/api/users", undefined, { auth: "a.b.c" });
+await call("expired token", "GET", "/api/users", undefined, { auth: (() => {
+    const h = Buffer.from(JSON.stringify({ alg: "EdDSA", typ: "JWT" })).toString("base64url");
+    const p = Buffer.from(JSON.stringify({ iss: "x", iat: 1, exp: 2 })).toString("base64url");
+    return `${h}.${p}.${crypto.sign(null, Buffer.from(`${h}.${p}`), KEY).toString("base64url")}`;
+})() });
+await call("users empty", "GET", "/api/users");
+await call("add alice", "POST", "/api/users", { name: "alice" });
+await call("add bob", "POST", "/api/users", { name: "bob" });
+await call("add alice again", "POST", "/api/users", { name: "alice" });
+await call("add bad name", "POST", "/api/users", { name: "a b" });
+await call("add long name", "POST", "/api/users", { name: "x".repeat(33) });
+await call("add no body", "POST", "/api/users");
+await call("add too big", "POST", "/api/users", undefined, { raw: JSON.stringify({ name: "y", pad: "z".repeat(2000) }) });
+await call("add broken json", "POST", "/api/users", undefined, { raw: "{\"name\":" });
+await call("users", "GET", "/api/users");
+await call("stats", "GET", "/api/users/stats");
+await call("fetch alice", "POST", "/api/users/alice");
+await call("fetch nobody", "POST", "/api/users/nobody");
+await call("fetch bad name", "POST", "/api/users/a%20b");
+await call("add peer", "POST", "/api/peers", { pub_key: P1, owner: "abcdef123456/m1/d1" });
+await call("add peer dup", "POST", "/api/peers", { pub_key: P1, owner: "abcdef123456/m1/d1" });
+await call("add peer bad owner", "POST", "/api/peers", { pub_key: P2, owner: "bad owner!" });
+await call("add peer bad key", "POST", "/api/peers", { pub_key: "nope", owner: "abcdef123456/m1/d2" });
+await call("add peer legacy", "POST", "/api/peers", { pub_key: P3, owner: "m7/d9" });
+await call("peers", "GET", "/api/peers");
+await call("rekey peer", "PUT", `/api/peers/${url64(P1)}`, { pub_key: P2 });
+await call("rekey missing", "PUT", `/api/peers/${url64(key("missing"))}`, { pub_key: key("other") });
+await call("rekey to taken", "PUT", `/api/peers/${url64(P2)}`, { pub_key: P3 });
+await call("rotate psk", "POST", `/api/peers/${url64(P2)}/psk`);
+await call("rotate psk missing", "POST", `/api/peers/${url64(key("missing"))}/psk`);
+await call("profile", "GET", "/api/profile");
+await call("add peer 4", "POST", "/api/peers", { pub_key: key("dev4"), owner: "abcdef123456/m1/d4" });
+await call("sync bad owner", "PUT", "/api/peers/sync", { owner: "BAD", keep: [] });
+await call("sync bad keep", "PUT", "/api/peers/sync", { owner: "abcdef123456", keep: "x" });
+await call("sync keep P2 + legacy P3", "PUT", "/api/peers/sync", { owner: "abcdef123456", keep: [P2, P3] });
+await call("peers after sync", "GET", "/api/peers");
+execSync(`awg set awg1 peer ${GHOST} allowed-ips 10.9.9.9/32`);
+await call("audit", "GET", "/api/audit");
+await call("audit clean bad", "POST", "/api/audit/clean", { pub_keys: "x" });
+await call("audit clean", "POST", "/api/audit/clean", { pub_keys: [GHOST, P2] });
+await call("delete peer", "DELETE", `/api/peers/${url64(P2)}`);
+await call("delete peer missing", "DELETE", `/api/peers/${url64(P2)}`);
+await call("delete bob", "DELETE", "/api/users/bob");
+await call("delete nobody", "DELETE", "/api/users/nobody");
+await call("shaping", "GET", "/api/shaping");
+await call("shaping bad", "PUT", "/api/shaping", { enabled: "yes", auto: true });
+await call("shaping bad mbit", "PUT", "/api/shaping", { enabled: true, auto: true, downMbit: 1.5, upMbit: 10 });
+await call("shaping missing width", "PUT", "/api/shaping", { enabled: true, auto: true, downMbit: 0, upMbit: 10 });
+await call("shaping on", "PUT", "/api/shaping", { enabled: true, auto: false, downMbit: 285, upMbit: 280 });
+await call("shaping get on", "GET", "/api/shaping");
+await call("stats priority", "GET", "/api/users/stats");
+await call("metrics", "GET", "/api/metrics");
+await call("shaping off", "PUT", "/api/shaping", { enabled: false, auto: true, downMbit: 0, upMbit: 0 });
+await call("monitor job", "GET", "/api/monitor/job");
+await call("monitor install (no cli)", "POST", "/api/monitor/install");
+await call("awg status", "GET", "/awg/status");
+await call("awg start (already up)", "POST", "/awg/start");
+await call("reissue", "POST", "/api/users/reissue");
+await call("users after reissue", "GET", "/api/users");
+await call("awg restart", "POST", "/awg/restart");
+await call("health after restart", "GET", "/health", undefined, { auth: false });
+await call("upgrade", "POST", "/awg/upgrade");
+await call("profile after upgrade", "GET", "/api/profile");
+await call("users after upgrade", "GET", "/api/users");
+await call("fetch alice after upgrade", "POST", "/api/users/alice");
+await call("health final", "GET", "/health", undefined, { auth: false });
+await call("unknown route", "GET", "/api/nope");
+await call("wrong method", "PATCH", "/api/users");
+
+fs.writeFileSync(out, JSON.stringify({ gen, steps }, null, 1));
+console.log(`scenario: ${steps.length} steps → ${out}`);

tools/diffbench/scenario-ui.ts

@@ -0,0 +1,301 @@
+// Сценарий для awg-ui: одинаковая последовательность запросов к TS- и Go-версии панели.
+// Запуск: awg-ui/node_modules/.bin/tsx tools/diffbench/scenario-ui.ts <out.json>
+// Окружение: UI (http://127.0.0.1:8080), SUB (http://127.0.0.1:8443), AGENT_BIN — бинарник
+// awg-control для ноды (join по строке из панели), BENCH_DIR — каталог с ключами стенда.
+import crypto from "crypto";
+import fs from "fs";
+import { spawn, execSync, type ChildProcess } from "child_process";
+import { decodeSenLink, signRequest } from "../../awg-ui/sen";
+
+const UI = process.env.UI ?? "http://127.0.0.1:8080";
+const SUB = process.env.SUB ?? "http://127.0.0.1:8443";
+const out = process.argv[2];
+const BENCH = process.env.BENCH_DIR ?? "/var/lib/uibench";
+
+type Step = { name: string; method: string; path: string; status: number; ctype: string; body: unknown; text?: string };
+const steps: Step[] = [];
+const sleep = (ms: number) => new Promise(r => setTimeout(r, ms));
+
+async function call(name: string, method: string, path: string, body?: unknown,
+    o: { token?: string | null; key?: string; raw?: string; headers?: Record<string, string>; base?: string } = {}) {
+    const h: Record<string, string> = { ...(o.headers ?? {}) };
+    if (o.token) h.authorization = `Bearer ${o.token}`;
+    if (o.key) h["x-api-key"] = o.key;
+    let data: string | undefined;
+    if (o.raw !== undefined) { h["content-type"] = "application/json"; data = o.raw; }
+    else if (body !== undefined) { h["content-type"] = "application/json"; data = JSON.stringify(body); }
+    const r = await fetch((o.base ?? UI) + path, { method, headers: h, body: data });
+    const ctype = (r.headers.get("content-type") ?? "").split(";")[0];
+    const text = await r.text();
+    let parsed: unknown = text;
+    if (ctype === "application/json") { try { parsed = JSON.parse(text); } catch { /* как есть */ } }
+    if (ctype === "text/html" && text.length > 2000) parsed = text.slice(0, 200);   // index.html
+    steps.push({ name, method, path, status: r.status, ctype, body: parsed, text: ctype === "application/json" ? text : undefined });
+    return parsed as any;
+}
+
+// ── Подписанные запросы устройства (/sub/v1) ────────────────────────────────
+const seedKey = (s: string) => crypto.createPrivateKey({
+    key: Buffer.concat([Buffer.from("302e020100300506032b657004220420", "hex"), crypto.createHash("sha256").update(s).digest()]),
+    format: "der", type: "pkcs8",
+});
+const rawPub = (k: crypto.KeyObject) => (crypto.createPublicKey(k).export({ type: "spki", format: "der" }) as Buffer).subarray(12);
+const wgPub = (s: string) => crypto.createHash("sha256").update("wg:" + s).digest("base64");
+
+let tsBump = 0;
+async function subCall(name: string, method: string, path: string, body: unknown, auth: crypto.KeyObject | null, device?: number, extra: Record<string, string> = {}) {
+    const raw = body === undefined ? "" : JSON.stringify(body);
+    const ts = Math.floor(Date.now() / 1000) + (tsBump++ % 2);   // разные подписи для одинаковых запросов
+    const h: Record<string, string> = { ...extra };
+    if (auth) { h["x-sen-ts"] = String(ts); h["x-sen-sig"] = signRequest(method, path, ts, raw, auth); }
+    if (device !== undefined) h["x-sen-device"] = String(device);
+    return call(name, method, path, undefined, { raw: body === undefined ? undefined : raw, headers: h, base: SUB });
+}
+
+// ── Сценарий ────────────────────────────────────────────────────────────────
+async function main() {
+let agent: ChildProcess | null = null;
+try {
+    await call("brand", "GET", "/ui/brand");
+    await call("login bad", "POST", "/login", { user: "admin", pass: "nope" });
+    await call("login no body", "POST", "/login");
+    await call("login broken json", "POST", "/login", undefined, { raw: "{" });
+    const { token } = await call("login", "POST", "/login", { user: "admin", pass: "benchpass" });
+    const T = { token };
+
+    await call("apikeys no auth", "GET", "/ui/apikeys");
+    await call("apikeys bad token", "GET", "/ui/apikeys", undefined, { token: "a.b.c" });
+    await call("nodes no auth", "GET", "/ui/nodes");
+    await call("proxy no auth", "GET", "/api/users");
+
+    // прокси к awg-ctrl
+    await call("proxy health", "GET", "/health", undefined, T);
+    await call("proxy users", "GET", "/api/users", undefined, T);
+    await call("proxy add alice", "POST", "/api/users", { name: "alice" }, T);
+    await call("proxy add bad", "POST", "/api/users", { name: "a b" }, T);
+    await call("proxy unknown", "GET", "/api/nope?x=1", undefined, T);
+    await call("proxy server 5", "GET", "/api/users", undefined, { ...T, headers: { "x-server-id": "5" } });
+    await call("proxy server junk", "GET", "/api/users/stats", undefined, { ...T, headers: { "x-server-id": "junk" } });
+
+    // ключи API
+    await call("apikeys empty", "GET", "/ui/apikeys", undefined, T);
+    await call("apikey bad label", "POST", "/ui/apikeys", { label: "bad!" }, T);
+    await call("apikey no label", "POST", "/ui/apikeys", {}, T);
+    await call("apikey bad servers", "POST", "/ui/apikeys", { label: "k", servers: [9] }, T);
+    await call("apikey empty servers", "POST", "/ui/apikeys", { label: "k", servers: [] }, T);
+    const k1 = await call("apikey create", "POST", "/ui/apikeys", { label: "main key" }, T);
+    const k2 = await call("apikey create sid", "POST", "/ui/apikeys", { label: "second", server_id: 0, servers: [0, 0] }, T);
+    await call("apikeys list", "GET", "/ui/apikeys", undefined, T);
+    await call("apikey patch bad", "PATCH", "/ui/apikeys/" + k2.id, { servers: [] }, T);
+    await call("apikey patch missing", "PATCH", "/ui/apikeys/999", { servers: [0] }, T);
+    await call("apikey patch", "PATCH", "/ui/apikeys/" + k2.id, { servers: [0] }, T);
+    await call("apikey delete bad", "DELETE", "/ui/apikeys/x", undefined, T);
+    await call("apikey delete", "DELETE", "/ui/apikeys/" + k2.id, undefined, T);
+
+    // внешний API: пользователи
+    const K = { key: k1.key as string };
+    await call("v1 no key", "GET", "/api/v1/users");
+    await call("v1 bad key", "GET", "/api/v1/users", undefined, { key: "awgk_nope" });
+    await call("v1 users", "GET", "/api/v1/users", undefined, K);
+    await call("v1 add bob", "POST", "/api/v1/users", { name: "bob" }, K);
+    await call("v1 add bob again", "POST", "/api/v1/users", { name: "bob" }, K);
+    await call("v1 add no name", "POST", "/api/v1/users", {}, K);
+    await call("v1 get bob", "GET", "/api/v1/users/bob", undefined, K);
+    await call("v1 get nobody", "GET", "/api/v1/users/nobody", undefined, K);
+    await call("v1 get escaped", "GET", "/api/v1/users/b%20b", undefined, K);
+    await call("v1 server outside", "GET", "/api/v1/users", undefined, { ...K, headers: { "x-server-id": "3" } });
+    await call("v1 unknown with key", "GET", "/api/v1/zzz", undefined, K);
+    await call("v1 delete bob", "DELETE", "/api/v1/users/bob", undefined, K);
+
+    // ноды: заводим и подключаем агента к тому же awg-ctrl
+    await call("nodes list", "GET", "/ui/nodes", undefined, T);
+    await call("node bad name", "POST", "/ui/nodes", { name: "" }, T);
+    const n1 = await call("node create", "POST", "/ui/nodes", { name: "edge-1", host: "127.0.0.1" }, T);
+    await call("node rename bad", "PATCH", "/ui/nodes/" + n1.id, { name: "a<b" }, T);
+    await call("node rename", "PATCH", "/ui/nodes/" + n1.id, { name: "edge-one" }, T);
+    await call("node rejoin", "POST", `/ui/nodes/${n1.id}/join`, { host: "127.0.0.1" }, T).then(async r => {
+        const j = JSON.parse(Buffer.from(String(r.join).slice("awgjoin://".length), "base64url").toString());
+        fs.rmSync(`${BENCH}/agent-node.key`, { force: true });
+        agent = spawn(process.env.AGENT_BIN!, ["agent"], {
+            env: { ...process.env, CORE_HOST: j.h, CORE_PORT: String(j.p), CORE_PIN: j.pin, NODE_ID: String(j.n), JOIN_SECRET: j.s,
+                AWGCTRL_PORT: "3005", NODE_KEY_FILE: `${BENCH}/agent-node.key`, VERSION: "0.9.9",
+                INTERNAL_AUTH_KEY_FILE: "/etc/amnezia/amneziawg/internal_auth_private.key", CLI_ENV_FILE: "" },
+            stdio: "ignore",
+        });
+    });
+    for (let i = 0; i < 100; i++) {
+        const r = await fetch(UI + "/ui/nodes", { headers: { authorization: `Bearer ${token}` } }).then(x => x.json()) as any;
+        if (r.nodes.some((n: any) => n.id === n1.id && n.online && n.health)) break;
+        await sleep(100);
+    }
+    await sleep(500);
+    await call("nodes online", "GET", "/ui/nodes", undefined, T);
+    await call("node join bound", "POST", `/ui/nodes/${n1.id}/join`, {}, T);
+    await call("proxy via node", "GET", "/api/users", undefined, { ...T, headers: { "x-server-id": String(n1.id) } });
+    await call("proxy via node awg", "GET", "/awg/status", undefined, { ...T, headers: { "x-server-id": String(n1.id) } });
+
+    // мастер-ключи
+    await call("mk list empty", "GET", "/ui/masterkeys", undefined, T);
+    await call("mk bad label", "POST", "/ui/masterkeys", { label: "a\nb" }, T);
+    await call("mk bad limit", "POST", "/ui/masterkeys", { label: "x", device_limit: 0 }, T);
+    await call("mk bad servers", "POST", "/ui/masterkeys", { label: "x", servers: [42] }, T);
+    const m1 = await call("mk create", "POST", "/ui/masterkeys", { label: "Семья", device_limit: 2 }, T);
+    const m2 = await call("mk create multi", "POST", "/ui/masterkeys", { label: "Multi", servers: [n1.id, 0] }, T);
+    await call("mk list", "GET", "/ui/masterkeys", undefined, T);
+    const link = await call("mk link", "GET", `/ui/masterkeys/${m1.id}/link`, undefined, T);
+    await call("mk link by uuid", "GET", `/ui/masterkeys/${m1.uuid.toUpperCase()}/link`, undefined, T);
+    await call("mk link missing", "GET", "/ui/masterkeys/999/link", undefined, T);
+    const sen = decodeSenLink(link.link);
+    const secret = sen.secret.toString("base64url");
+
+    // /sub/v1: регистрация и опрос устройства
+    const d1 = seedKey("dev1"), d2 = seedKey("dev2"), d3 = seedKey("dev3");
+    const reg = (dev: string, k: crypto.KeyObject, sec: string, extra: object = {}) => ({
+        sub: sec, device_id: dev, device_name: "Phone " + dev, platform: "android", pub_key: wgPub(dev),
+        auth_pub: rawPub(k).toString("base64url"), version: "1.2.3", ...extra,
+    });
+    await subCall("sub unknown path", "GET", "/sub/v1/nope", undefined, null);
+    await subCall("sub broken json", "POST", "/sub/v1/peek", undefined, null).catch(() => {});
+    await call("sub broken json raw", "POST", "/sub/v1/peek", undefined, { raw: "{", base: SUB });
+    await subCall("sub peek bad", "POST", "/sub/v1/peek", { sub: "x" }, null);
+    await subCall("sub peek missing", "POST", "/sub/v1/peek", { sub: "A".repeat(22) }, null);
+    await subCall("sub peek", "POST", "/sub/v1/peek", { sub: secret }, null);
+    await subCall("sub register bad", "POST", "/sub/v1/register", { sub: secret }, d1);
+    await subCall("sub register unsigned", "POST", "/sub/v1/register", reg("d1", d1, secret), null);
+    const r1 = await subCall("sub register d1", "POST", "/sub/v1/register", reg("d1", d1, secret), d1, { "x-sen-device": "77" });
+    const dev1 = JSON.parse(r1.body).device;
+    const r2 = await subCall("sub register d2", "POST", "/sub/v1/register", reg("d2", d2, secret), d2);
+    const dev2 = JSON.parse(r2.body).device;
+    await subCall("sub register over limit", "POST", "/sub/v1/register", reg("d3", d3, secret), d3);
+    await subCall("sub config", "GET", "/sub/v1/config", undefined, d1, dev1, { "x-sen-version": "1.2.4" });
+    await subCall("sub config wrong key", "GET", "/sub/v1/config", undefined, d2, dev1);
+    await subCall("sub config no sig", "GET", "/sub/v1/config", undefined, null, dev1);
+    await subCall("sub config gone", "GET", "/sub/v1/config", undefined, d1, 9999);
+    await subCall("sub devices", "GET", "/sub/v1/devices", undefined, d2, dev2);
+    await subCall("sub rekey bad", "POST", "/sub/v1/rekey", { pub_key: "x" }, d1, dev1);
+    await subCall("sub rekey same", "POST", "/sub/v1/rekey", { pub_key: wgPub("d1") }, d1, dev1);
+    await subCall("sub rekey taken", "POST", "/sub/v1/rekey", { pub_key: wgPub("d2") }, d1, dev1);
+    await subCall("sub rekey", "POST", "/sub/v1/rekey", { pub_key: wgPub("d1-new") }, d1, dev1);
+    // повтор той же подписи — replay
+    {
+        const ts = Math.floor(Date.now() / 1000);
+        const sig = signRequest("GET", "/sub/v1/config", ts, "", d2);
+        const h = { "x-sen-ts": String(ts), "x-sen-sig": sig, "x-sen-device": String(dev2) };
+        await call("sub config sig once", "GET", "/sub/v1/config", undefined, { headers: h, base: SUB });
+        await call("sub config replay", "GET", "/sub/v1/config", undefined, { headers: h, base: SUB });
+    }
+    // устройство на ключе с двумя серверами (нода — тот же awg-ctrl)
+    const link2 = await call("mk2 link", "GET", `/ui/masterkeys/${m2.id}/link`, undefined, T);
+    const secret2 = decodeSenLink(link2.link).secret.toString("base64url");
+    const r3 = await subCall("sub register multi", "POST", "/sub/v1/register", reg("d3", d3, secret2), d3);
+    const dev3 = JSON.parse(r3.body).device;
+    await subCall("sub config multi", "GET", "/sub/v1/config", undefined, d3, dev3);
+
+    // панель: устройства и мастер-ключи
+    await call("mk devices", "GET", `/ui/masterkeys/${m1.id}/devices`, undefined, T);
+    await call("mk2 devices", "GET", `/ui/masterkeys/${m2.id}/devices`, undefined, T);
+    await call("dev rekey", "POST", `/ui/devices/${dev2}/rekey`, undefined, T);
+    await call("dev psk", "POST", `/ui/devices/${dev2}/psk`, undefined, T);
+    await call("dev missing", "POST", "/ui/devices/999/psk", undefined, T);
+    await call("mk rekey", "POST", `/ui/masterkeys/${m1.id}/rekey`, undefined, T);
+    await subCall("sub config after rekey flag", "GET", "/sub/v1/config", undefined, d2, dev2);
+    await call("mk patch bad", "PATCH", `/ui/masterkeys/${m1.id}`, { device_limit: 101 }, T);
+    await call("mk patch limit", "PATCH", `/ui/masterkeys/${m1.id}`, { label: "Семья 2", device_limit: 1 }, T);
+    await subCall("sub config unbound", "GET", "/sub/v1/config", undefined, d2, dev2);
+    await call("mk2 patch servers", "PATCH", `/ui/masterkeys/${m2.id}`, { servers: [0] }, T);
+    await call("mk rotate", "POST", `/ui/masterkeys/${m1.id}/rotate`, undefined, T);
+    await subCall("sub peek old secret", "POST", "/sub/v1/peek", { sub: secret }, null);
+    await call("dev delete", "DELETE", `/ui/devices/${dev1}`, undefined, T);
+    await subCall("sub config deleted", "GET", "/sub/v1/config", undefined, d1, dev1);
+    await subCall("sub delete self", "DELETE", "/sub/v1/device", undefined, d3, dev3);
+
+    // внешний API: мастер-ключи
+    await call("v1 mk list", "GET", "/api/v1/masterkeys", undefined, K);
+    await call("v1 mk create outside", "POST", "/api/v1/masterkeys", { label: "ext", servers: [n1.id] }, K);
+    const em = await call("v1 mk create", "POST", "/api/v1/masterkeys", { label: "ext" }, K);
+    await call("v1 mk get", "GET", `/api/v1/masterkeys/${em.id}`, undefined, K);
+    await call("v1 mk get by uuid", "GET", `/api/v1/masterkeys/${em.uuid}`, undefined, K);
+    await call("v1 mk get invisible", "GET", `/api/v1/masterkeys/${m2.id}`, undefined, K);
+    await call("v1 mk patch", "PATCH", `/api/v1/masterkeys/${em.id}`, { device_limit: 5 }, K);
+    await call("v1 mk rotate", "POST", `/api/v1/masterkeys/${em.id}/rotate`, undefined, K);
+    await call("v1 mk rekey", "POST", `/api/v1/masterkeys/${em.id}/rekey`, undefined, K);
+    await call("v1 mk devices", "GET", `/api/v1/masterkeys/${em.id}/devices`, undefined, K);
+    await call("v1 mk device missing", "DELETE", `/api/v1/masterkeys/${em.id}/devices/${dev2}`, undefined, K);
+    await call("v1 mk delete", "DELETE", `/api/v1/masterkeys/${em.id}`, undefined, K);
+
+    // аудит
+    await call("audit get", "GET", "/ui/masterkeys/audit", undefined, T);
+    await call("audit settings bad", "PUT", "/ui/masterkeys/audit/settings", { every_h: 0 }, T);
+    await call("audit settings", "PUT", "/ui/masterkeys/audit/settings", { clean: false, every_h: 2, max: 5 }, T);
+    await call("audit run", "POST", "/ui/masterkeys/audit", undefined, T);
+    await call("audit clean", "POST", "/ui/masterkeys/audit/clean", undefined, T);
+
+    // метрики
+    await call("metrics no token", "GET", "/metrics");
+    await call("metrics token none", "GET", "/ui/metrics-token", undefined, T);
+    const mt = await call("metrics token create", "POST", "/ui/metrics-token", undefined, T);
+    await call("metrics", "GET", "/metrics", undefined, { token: mt.token });
+    await call("metrics token view", "GET", "/ui/metrics-token", undefined, T);
+    await call("metrics token delete", "DELETE", "/ui/metrics-token", undefined, T);
+    await call("metrics after delete", "GET", "/metrics", undefined, { token: mt.token });
+
+    // монитор (Prometheus не запущен)
+    await call("monitor", "GET", "/ui/monitor", undefined, T);
+    await call("monitor overview bad", "GET", "/ui/monitor/overview?range=2h", undefined, T);
+    await call("monitor overview", "GET", "/ui/monitor/overview?range=6h", undefined, T);
+
+    // аудит с «мёртвыми»: лишний пир панели у awg-ctrl и пир в ядре без записи
+    {
+        const panel = fs.readFileSync(__dirname + "/../../awg-ui/panel.id", "utf8").trim();
+        await call("orphan add", "POST", "/api/peers", { pub_key: wgPub("orphan"), owner: `${panel}/m1/d77` }, T);
+        await call("foreign add", "POST", "/api/peers", { pub_key: wgPub("foreign"), owner: "ffffffffffff/m1/d1" }, T);
+        execSync(`awg set awg1 peer ${wgPub("ghost")} allowed-ips 10.9.9.9/32`);
+        await call("audit run 1", "POST", "/ui/masterkeys/audit", undefined, T);
+        await call("audit clean unconfirmed", "POST", "/ui/masterkeys/audit/clean", undefined, T);
+        await call("audit run 2", "POST", "/ui/masterkeys/audit", undefined, T);
+        await call("audit clean confirmed", "POST", "/ui/masterkeys/audit/clean", undefined, T);
+        await call("audit after clean", "GET", "/ui/masterkeys/audit", undefined, T);
+    }
+
+    // ключ API на ноде мешает её удалить; потом нода уходит офлайн
+    const k3 = await call("apikey on node", "POST", "/ui/apikeys", { label: "node only", servers: [n1.id] }, T);
+    await call("node delete key veto", "DELETE", `/ui/nodes/${n1.id}`, undefined, T);
+    await call("apikey to both", "PATCH", "/ui/apikeys/" + k3.id, { servers: [0, n1.id] }, T);
+    await call("v1 users on node", "GET", "/api/v1/users", undefined, { key: k3.key, headers: { "x-server-id": String(n1.id) } });
+    if (agent) { (agent as ChildProcess).kill(); agent = null; }
+    for (let i = 0; i < 50; i++) {
+        const r = await fetch(UI + "/ui/nodes", { headers: { authorization: `Bearer ${token}` } }).then(x => x.json()) as any;
+        if (r.nodes.some((n: any) => n.id === n1.id && !n.online)) break;
+        await sleep(100);
+    }
+    await call("nodes offline", "GET", "/ui/nodes", undefined, T);
+    await call("proxy via offline node", "GET", "/api/users", undefined, { ...T, headers: { "x-server-id": String(n1.id) } });
+    await call("mk2 back to node", "PATCH", `/ui/masterkeys/${m2.id}`, { servers: [0, n1.id] }, T);
+    await call("mk2 devices offline", "GET", `/ui/masterkeys/${m2.id}/devices`, undefined, T);
+
+    // удаление ноды
+    await call("node delete in use", "DELETE", `/ui/nodes/${n1.id}`, undefined, T);
+    await call("mk2 delete", "DELETE", `/ui/masterkeys/${m2.id}`, undefined, T);
+    await call("node delete pending", "DELETE", `/ui/nodes/${n1.id}`, undefined, T);
+    await call("node delete", "DELETE", `/ui/nodes/${n1.id}?force=1`, undefined, T);
+    await call("apikeys after node delete", "GET", "/ui/apikeys", undefined, T);
+    await call("node delete again", "DELETE", `/ui/nodes/${n1.id}`, undefined, T);
+    await call("mk list final", "GET", "/ui/masterkeys", undefined, T);
+
+    // статика и общие ответы
+    await call("static index", "GET", "/");
+    await call("static spa", "GET", "/some/route");
+    await call("static ui fallback", "GET", "/ui/unknown", undefined, T);
+    await call("post unknown", "POST", "/nope");
+    await call("wrong method", "PUT", "/ui/apikeys", undefined, T);
+    await call("logout", "POST", "/logout", undefined, T);
+    await call("after logout", "GET", "/ui/apikeys", undefined, T);
+} finally {
+    if (agent) (agent as ChildProcess).kill();
+}
+
+fs.writeFileSync(out, JSON.stringify({ steps }, null, 1));
+console.log(`scenario-ui: ${steps.length} steps → ${out}`);
+}
+
+main().catch(e => { console.error(e); fs.writeFileSync(out, JSON.stringify({ steps, error: String(e) }, null, 1)); process.exit(1); });

tools/diffbench/setup.sh

@@ -0,0 +1,53 @@
+#!/bin/sh
+# Чистое состояние «сервера»: awg1.conf нужного поколения, ключи, пустые базы, заглушки.
+# GEN=2|3.1, WITH_I1=1 — добавить I1 в conf (install.sh его не пишет).
+set -e
+GEN="${GEN:-2}"
+D=/etc/amnezia/amneziawg
+rm -rf /etc/amnezia /var/lib/stub /run/bench
+mkdir -p "$D" /var/lib/stub /run/bench
+node -e 'const c=require("crypto");process.stdout.write(c.createHash("sha256").update("server").digest("base64"))' > /etc/amnezia/server_private.key
+chmod 600 /etc/amnezia/server_private.key
+node -e 'const c=require("crypto");const p=require("fs").readFileSync("/etc/amnezia/server_private.key","utf8").trim();process.stdout.write(c.createHash("sha256").update("pub:"+p).digest("base64")+"\n")' > "$D/server_public.key"
+openssl genpkey -algorithm ed25519 -out "$D/internal_auth_private.key" 2>/dev/null
+openssl pkey -in "$D/internal_auth_private.key" -pubout -out "$D/internal_auth_public.key"
+PRIV=$(cat /etc/amnezia/server_private.key)
+cat > "$D/awg1.conf" <<CONF
+[Interface]
+Address = 10.9.0.1/16
+MTU = 1376
+PostUp = awg set awg1 private-key /etc/amnezia/server_private.key; iptables -A FORWARD -i awg1 -j ACCEPT; iptables -t nat -A POSTROUTING -o eth0 -j MASQUERADE
+PreDown = iptables -D FORWARD -i awg1 -j ACCEPT; iptables -t nat -D POSTROUTING -o eth0 -j MASQUERADE
+ListenPort = 47619
+PrivateKey = ${PRIV}
+Jc = 6
+Jmin = 10
+Jmax = 50
+S1 = 90
+S2 = 45
+S3 = 37
+S4 = ${S4:-14}
+H1 = 1224800044-2116730834
+H2 = 2122053282-2133204808
+H3 = 2133604274-2140756116
+H4 = 2143656228-2147444225
+CONF
+if [ "${WITH_I1:-0}" = "1" ]; then
+  echo 'I1 = <r 2><b 0x858000010001000000000669636c6f756403636f6d0000010001c00c000100010000105a00044d583737>' >> "$D/awg1.conf"
+fi
+if [ "$GEN" = "3.1" ]; then
+cat >> "$D/awg1.conf" <<CONF
+HeaderProtectionKey = AAECAwQFBgcICQoLDA0ODxAREhMUFRYXGBkaGxwdHh8=
+ContentPaddingAddition = 10-100
+RekeyAfterTime = 100-120
+RekeyTimeout = 3-7
+RejectAfterTime = 150-180
+KeepaliveTimeout = 5-15
+MaxHandshakeAttempts = 15-20
+CONF
+fi
+chmod 600 "$D/awg1.conf"
+echo '{"up":false,"n":0,"peers":{}}' > /var/lib/stub/state.json
+: > /var/lib/stub/log.jsonl
+awg-quick up awg1
+: > /var/lib/stub/log.jsonl

tools/diffbench/stubs/stub.mjs

@@ -0,0 +1,143 @@
+// Заглушки системных команд для дифференциального стенда: awg, awg-quick, ip, tc, nft, modinfo.
+// Детерминированные ключи (счётчик), состояние интерфейса в JSON, журнал каждого вызова.
+// Одинаково ведут себя для TS- и Go-версии — сравнивается то, что версии с ними делают.
+import fs from "fs";
+import crypto from "crypto";
+
+const DIR = "/var/lib/stub";
+const STATE = `${DIR}/state.json`;
+const LOG = `${DIR}/log.jsonl`;
+const [, , cmd, ...args] = process.argv;
+
+const load = () => { try { return JSON.parse(fs.readFileSync(STATE, "utf8")); } catch { return { up: false, n: 0, peers: {} }; } };
+const save = s => fs.writeFileSync(STATE, JSON.stringify(s, null, 1));
+const b64 = s => crypto.createHash("sha256").update(s).digest("base64");
+const pubOf = priv => b64("pub:" + priv.trim());
+const readStdin = () => { try { return fs.readFileSync(0, "utf8"); } catch { return ""; } };
+
+let stdin = "";
+const needsStdin = (cmd === "awg" && args[0] === "pubkey") || (cmd === "nft" && args.includes("-"));
+if (needsStdin) stdin = readStdin();
+
+const entry = { cmd, args };
+if (stdin) entry.stdin = stdin;
+// файлы, которые передают по пути (PSK, syncconf), пишем в журнал содержимым: имя у них со временем
+const fileArgs = [];
+for (let i = 0; i < args.length; i++) {
+    if (["preshared-key", "private-key"].includes(args[i]) || (cmd === "awg" && args[0] === "syncconf" && i === 2)) {
+        try { fileArgs.push(fs.readFileSync(args[i + (args[0] === "syncconf" ? 0 : 1)], "utf8")); } catch { fileArgs.push("<unreadable>"); }
+    }
+}
+if (fileArgs.length) entry.files = fileArgs;
+fs.appendFileSync(LOG, JSON.stringify(entry) + "\n");
+
+const out = s => process.stdout.write(s);
+const st = load();
+
+function parsePeers(text) {
+    const peers = {};
+    for (const block of text.split(/^\[Peer\]/m).slice(1)) {
+        const g = k => block.match(new RegExp(`^\\s*${k}\\s*=\\s*(.*)$`, "m"))?.[1]?.trim();
+        const pub = g("PublicKey");
+        if (pub) peers[pub] = { psk: g("PresharedKey") ?? "", allowed: g("AllowedIPs") ?? "", ka: g("PersistentKeepalive") ?? "" };
+    }
+    return peers;
+}
+
+function serverPub() {
+    try { return pubOf(fs.readFileSync("/etc/amnezia/server_private.key", "utf8")); } catch { return "(none)"; }
+}
+
+switch (cmd) {
+    case "awg": {
+        const [sub, iface, ...rest] = args;
+        if (sub === "--version") { out("awg-tools v1.0.20210914 - https://amnezia.org\n"); break; }
+        if (sub === "genkey") { st.n++; save(st); out(b64("priv" + st.n) + "\n"); break; }
+        if (sub === "genpsk") { st.n++; save(st); out(b64("psk" + st.n) + "\n"); break; }
+        if (sub === "pubkey") { out(pubOf(stdin) + "\n"); break; }
+        if (sub === "show") {
+            if (!st.up) { process.stderr.write(`Unable to access interface: No such device\n`); process.exit(1); }
+            const pubs = Object.keys(st.peers);
+            if (rest[0] === "dump") {
+                out(`(hidden)\t${serverPub()}\t47619\toff\n`);
+                for (const p of pubs) out(`${p}\t(hidden)\t(none)\t${st.peers[p].allowed}\t0\t0\t0\t${st.peers[p].ka || "off"}\n`);
+            } else if (rest[0] === "peers") {
+                for (const p of pubs) out(p + "\n");
+            } else {
+                out(`interface: ${iface}\n  public key: ${serverPub()}\n  private key: (hidden)\n  listening port: 47619\n`);
+                for (const p of pubs) out(`\npeer: ${p}\n  preshared key: (hidden)\n  allowed ips: ${st.peers[p].allowed}\n`);
+            }
+            break;
+        }
+        if (sub === "set") {
+            if (!st.up) { process.stderr.write("Unable to modify interface: No such device\n"); process.exit(1); }
+            const i = rest.indexOf("peer");
+            if (i >= 0) {
+                const pub = rest[i + 1];
+                if (rest.includes("remove")) { delete st.peers[pub]; }
+                else {
+                    const p = st.peers[pub] ?? { psk: "", allowed: "", ka: "" };
+                    const k = rest.indexOf("allowed-ips"); if (k >= 0) p.allowed = rest[k + 1];
+                    const a = rest.indexOf("persistent-keepalive"); if (a >= 0) p.ka = rest[a + 1];
+                    const s = rest.indexOf("preshared-key"); if (s >= 0) { try { p.psk = fs.readFileSync(rest[s + 1], "utf8").trim(); } catch {} }
+                    st.peers[pub] = p;
+                }
+            }
+            save(st);
+            break;
+        }
+        if (sub === "syncconf") {
+            if (!st.up) { process.stderr.write("Unable to modify interface: No such device\n"); process.exit(1); }
+            st.peers = parsePeers(fs.readFileSync(rest[0], "utf8"));
+            save(st);
+            break;
+        }
+        process.stderr.write(`stub awg: unsupported ${args.join(" ")}\n`); process.exit(1);
+    }
+    case "awg-quick": {
+        const [sub] = args;
+        if (sub === "up") {
+            if (st.up) { process.stderr.write("awg-quick: `awg1' already exists\n"); process.exit(1); }
+            if (process.env.STUB_UP_FAIL === "1") { process.stderr.write("RTNETLINK answers: Invalid argument\n"); process.exit(1); }
+            st.up = true;
+            try { st.peers = parsePeers(fs.readFileSync("/etc/amnezia/amneziawg/awg1.conf", "utf8")); } catch { st.peers = {}; }
+        } else if (sub === "down") {
+            if (!st.up) { process.stderr.write("awg-quick: `awg1' is not a WireGuard interface\n"); process.exit(1); }
+            st.up = false; st.peers = {};
+        }
+        save(st);
+        break;
+    }
+    case "ip": {
+        const a = args.join(" ");
+        if (a === "route show default") out("default via 203.0.113.1 dev eth0 proto static\n");
+        else if (a.startsWith("addr show")) out("2: eth0: <BROADCAST,MULTICAST,UP> mtu 1500\n    inet 203.0.113.7/24 brd 203.0.113.255 scope global eth0\n");
+        else if (a === "link show ifb-awg") { if (!st.ifb) process.exit(1); out("5: ifb-awg: <BROADCAST,NOARP,UP> mtu 1500\n"); }
+        else if (a.startsWith("link add ifb-awg")) { st.ifb = true; save(st); }
+        else if (a.startsWith("link del ifb-awg")) { if (!st.ifb) process.exit(1); st.ifb = false; save(st); }
+        break;
+    }
+    case "tc": {
+        const a = args.join(" ");
+        st.tc ??= {};
+        if (a.startsWith("qdisc replace dev")) { st.tc[args[3] + ":root"] = a; save(st); }
+        else if (a.startsWith("qdisc add dev") && a.includes("ingress")) { st.tc[args[3] + ":ingress"] = a; save(st); }
+        else if (a.startsWith("filter add dev")) { st.tc[args[3] + ":filter"] = a; save(st); }
+        else if (a.startsWith("qdisc del dev")) {
+            const key = args[3] + ":" + (args[4] === "root" ? "root" : "ingress");
+            if (!st.tc[key]) { process.stderr.write("Error: Cannot delete qdisc with handle of zero.\n"); process.exit(2); }
+            delete st.tc[key]; if (args[4] === "ingress") delete st.tc[args[3] + ":filter"]; save(st);
+        }
+        else if (a.startsWith("filter show dev")) { if (st.tc[args[3] + ":filter"]) out("filter parent ffff: protocol all pref 1 matchall\n\taction order 1: mirred (Egress Redirect to device ifb-awg) stolen\n"); }
+        else if (args[0] === "-s" && args[1] === "-j") { const dev = args[5]; out(st.tc[dev + ":root"] ? `[{"kind":"cake","handle":"8001:","root":true,"bytes":1000,"packets":10,"drops":2,"overlimits":0,"requeues":0,"backlog":0,"qlen":0}]\n` : "[]\n"); }
+        else if (a.startsWith("qdisc show dev")) { if (st.tc[args[3] + ":root"]) out(`qdisc cake 8001: root refcnt 2 bandwidth 285Mbit\n`); }
+        break;
+    }
+    case "nft": {
+        if (args[0] === "delete") { if (!st.nft) { process.stderr.write("Error: No such file or directory\n"); process.exit(1); } st.nft = false; save(st); }
+        else if (args.includes("-")) { st.nft = true; save(st); }
+        break;
+    }
+    case "modinfo": out((process.env.STUB_MODULE ?? "1.0.0") + "\n"); break;
+    default: process.stderr.write(`stub: unknown ${cmd}\n`); process.exit(127);
+}