Bump to Beta 0.3.2

All seven places the version is written down: .env, the copy in install.sh, the four package.json files and the /ui/brand example in the README. A master key can serve its devices from several servers; a server that joins a core as a node keeps its own panel.
Serve a master key's devices from several servers
2026-09-26 21:44:25 +03:00 · 2026-09-26 21:43:58 +03:00 · 2026-09-26 21:43:45 +03:00 · 2026-09-26 20:19:50 +03:00 · 2026-09-26 20:19:44 +03:00 · 2026-09-26 19:48:34 +03:00
49 changed files with 9392 additions and 533 deletions
@@ -11,4 +11,4 @@

 BRAND=Forgetting
 CHANNEL=Beta
-VERSION=0.2.0
+VERSION=0.3.2
@@ -43,7 +43,7 @@ jobs:
        run: |
          VERSION="${GITHUB_REF_NAME#v}"
          mkdir "awgcontrol-${VERSION}"
-          cp -r awg-ctrl awg-ui cli .env "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}/"

      # Токен выбираем в bash, а не выражением ${{ a || b }}: так поведение не
@@ -28,7 +28,7 @@ jobs:
        run: |
          VERSION="${GITHUB_REF_NAME#v}"
          mkdir "awgcontrol-${VERSION}"
-          cp -r awg-ctrl awg-ui cli .env "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}/"

      - name: Publish release
@@ -9,13 +9,13 @@
 | Компонент | Роль |
 |---|---|
 | **awg-ctrl** | Привилегированный REST-бэкенд. Управляет пирами через `awg`/`awg-quick`, ведёт SQLite-базу, генерирует `vpn://` ключи. Слушает только loopback. |
-| **awg-ui** | Express + React. Веб-панель, аутентификация (JWT), прокси к awg-ctrl. Единственный сервис, доступный по сети. |
+| **awg-ui** | Express + React. Веб-панель, аутентификация (JWT), прокси к awg-ctrl, публичный API `/api/v1` и своя база его ключей. Единственный сервис, доступный по сети. |
 | **cli** | Менеджер процессов: `start`/`stop`/`restart`/`status`, смена логина/пароля панели, интерактивное TUI-меню. |

 Внутренняя связь awg-ui → awg-ctrl подписывается асимметрично (Ed25519): приватный ключ только у awg-ui, awg-ctrl проверяет подпись публичным.

 ## Требования
- **ОС**: Ubuntu 24.04+ (Тесты проходили на Ubuntu 24.04.4 LTS)
+- **ОС**: Ubuntu 24.04+ (Тесты проходили на Ubuntu 24.04.4 LTS) или Debian 11–13 (поддержка экспериментальная: PPA amnezia подключается вручную, серия подбирается по релизу Debian и переопределяется через `AMNEZIA_PPA_SUITE`)
 - **Права**: root.
 - **Ядро**: kvm (не OpenVZ/LXC/Docker/WSL — нужен загружаемый kernel-модуль AmneziaWG).
 - **Заголовки ядра** под текущее ядро (для сборки DKMS-модуля).
@@ -43,45 +43,119 @@ AWG_GEN=auto bash <(curl -Ls https://git.ma7neko.ru/maeneko/forgetting/raw/branc
 переустановка не нужна, пользователи сохраняются, ключи перевыпускаются
 автоматически.

-### Свой источник и своё имя
+Источник архива и имя панели не зашиты в код — задаются переменными
+`REPO_BASE`, `REPO_FALLBACK`, `ARCHIVE_URL`, `BRAND` перед запуском установщика
+(подробности — в комментариях `install.sh` и в `.env`).

-В коде не зашиты ни репозиторий, ни бренд — всё задаётся окружением до запуска:
+## API

-| Переменная | По умолчанию | Зачем |
-|---|---|---|
-| `REPO_BASE` | `https://git.ma7neko.ru/maeneko/forgetting` | основной источник архива релиза |
-| `REPO_FALLBACK` | `https://github.com/maeneko/forgetting` | запасной, если в основном релиза ещё нет |
-| `ARCHIVE_URL` | — | полный URL архива, перекрывает оба варианта |
-| `BRAND` | из `.env` | имя продукта в баннерах, systemd-юните и панели |
+Наружу смотрят две независимые поверхности. **Публичный API** `/api/v1` —
+стабильный контракт для сторонних программ, авторизация по API-ключу.
+**Роуты панели** — всё, что умеет веб-интерфейс, авторизация по JWT. Базовый
+URL в обоих случаях — адрес сервера и порт, выбранный при установке.

-Путь релиза у Gitea и GitHub одинаковый (`<repo>/releases/download/v<версия>/awgcontrol-<версия>.tar.gz`),
-так что подходит любой из них. Если архив не найден в основном источнике,
-установщик предупреждает и берёт его из запасного.
+> [!WARNING]
+> Роуты панели отдают приватные поля пиров (`vpn_key`, `psk_key`) — это не
+> публичный контракт, в отличие от `/api/v1`. Не выставляй её порт в интернет
+> без TLS и ограничения по адресам.

-Архив собирается по тегу `v*`: на GitHub — `.github/workflows/release.yml`, в
-Gitea — `.gitea/workflows/release.yml` (сборка та же, публикация через API
-Gitea). Для запуска в Gitea репозиторий не должен быть pull-зеркалом, Actions
-включены, а runner зарегистрирован с меткой `ubuntu-latest`.
+### Публичный API (`/api/v1`)
+
+Ключ создаётся во вкладке «API-ключи» и уходит в заголовке `X-Api-Key`.
+Открытое значение показывается один раз при создании — на сервере лежит только
+SHA-256 и префикс для показа в списке. Наружу отдаются только публичные поля:
+`psk_key` и `pub_key` не покидают сервер.

 ```bash
-REPO_BASE=https://git.example.org/me/vpn BRAND="My VPN" \
-  bash <(curl -Ls https://git.example.org/me/vpn/raw/branch/main/install.sh)
+curl -s -X POST http://HOST:PORT/api/v1/users \
+  -H "X-Api-Key: awgk_xxx" -H "Content-Type: application/json" \
+  -d '{"name":"alice"}' | jq -r .vpn_key
 ```

-Имя панели, канал и версия лежат в `.env` в корне проекта (едет в архиве
-релиза, на сервере — `/opt/awg-control/.env`):
+| Метод | Что делает |
+|---|---|
+| `POST /api/v1/users` | Создаёт пира. Тело `{ "name": "alice" }`. `201` с `{ name, ip, gen, vpn_key }`; `400` — имя не прошло валидацию, `409` — уже есть |
+| `GET /api/v1/users` | Список со счётчиками: `{ users: [{ name, ip, key_gen, online, lastHandshake, rx, tx }] }` |
+| `GET /api/v1/users/:name` | `{ name, ip, gen, vpn_key }`; `404` — не найден |
+| `DELETE /api/v1/users/:name` | `{ "success": true, "name": "alice" }` |

-```env
-BRAND=Forgetting
-CHANNEL=Beta
-VERSION=0.2.0
+`gen` — поколение AmneziaWG, на параметрах которого собран ключ (`"2"` или
+`"3.1"`). Операции только CRD: у пира нет изменяемых полей, «перевыпустить»
+ключ = удалить и создать заново.
+
+| Код | Когда |
+|---|---|
+| `401 {"error":"API key required"}` | заголовка нет или он не начинается с `awgk_` |
+| `401 {"error":"Invalid API key"}` | ключ не найден — удалён или неверен |
+| `502 {"error":"awg-ctrl недоступен"}` | awg-ui посредничает, а awg-ctrl не отвечает |
+
+Ключи лежат в собственной БД панели (`/etc/amnezia/amneziawg/ui.db`) — вне
+каталога установки, поэтому переустановка их не трогает. Сама awg-ctrl про
+внешние ключи ничего не знает: awg-ui ходит к ней своей внутренней авторизацией.
+Управлять ключами можно и без панели, по JWT: `GET/POST /ui/apikeys` и
+`DELETE /ui/apikeys/:id`.
+
+### Авторизация панели
+
+```bash
+TOKEN=$(curl -s -X POST http://HOST:PORT/login \
+  -H "Content-Type: application/json" \
+  -d '{"user":"admin","pass":"***"}' | jq -r .token)
 ```

-Оттуда их читают CLI (баннер меню) и панель (вордмарк, `GET /ui/brand`).
-`BRAND=` при установке перекрывает значение из файла.
+| Метод | Ответ и ошибки |
+|---|---|
+| `POST /login` | `{ "token": "<JWT>" }`, срок 24 часа. `401` — неверная пара; `429` — больше 5 неудачных попыток с одного IP за 15 минут |
+| `POST /logout` | `{ "ok": true }`, токен отзывается немедленно |
+
+Дальше в каждый запрос: `Authorization: Bearer $TOKEN`. Ниже — роуты, которые
+дёргает сама панель; в отличие от `/api/v1` их форма может меняться.
+
+### Состояние
+
+| Метод | Ответ |
+|---|---|
+| `GET /ui/brand` | `{ "brand": "Forgetting", "channel": "Beta", "version": "0.3.2" }` — **без авторизации**, панель берёт отсюда вордмарк на экране логина |
+| `GET /health` | `{ "status", "server", "ip", "gen", "awg": { "status", "peers", "module", "tools" } }`. `200`, если интерфейс поднят, иначе `503` и `status: "degraded"` |
+| `GET /awg/status` | `{ "up": true, "peers": 3, "publicKey": "…" }` |
+
+`gen` — поколение AmneziaWG, на параметрах которого сейчас работает интерфейс:
+`"2"` или `"3.1"`. Оно выводится из `awg1.conf`, а не хранится отдельно.
+
+### Пользователи
+
+| Метод | Что делает |
+|---|---|
+| `POST /api/users` | Создаёт пира. Тело `{ "name": "alice" }`, имя — `a–z A–Z 0–9 _ -`, до 32 символов. `201` с `{ name, ip, pub_key, psk_key, vpn_key, key_gen, vpn_key_prev }`; `400` — имя не прошло валидацию, `409` — уже есть |
+| `GET /api/users` | Список: `{ users: [{ name, ip, pub_key, vpn_key, key_gen, online, lastHandshake }] }` |
+| `GET /api/users/stats` | То же без ключей, но со счётчиками: `{ users: [{ name, ip, key_gen, online, lastHandshake, rx, tx }] }` |
+| `POST /api/users/:name` | Возвращает пользователя целиком, включая `vpn_key`. Метод именно `POST`, чтобы ключ не оседал в логах и истории как параметр `GET`. `404` — не найден |
+| `DELETE /api/users/:name` | `{ "success": true, "name": "alice" }` |
+| `POST /api/users/reissue` | Пересобирает `vpn://` всем на текущих параметрах: `{ total, reissued, regenerated: [], backup }`. IP и ключевая пара сохраняются, клиентам нужно заново импортировать ключ; `backup` — путь к снимку базы, снятому перед проходом |
+
+```bash
+curl -s -X POST http://HOST:PORT/api/users \
+  -H "Authorization: Bearer $TOKEN" -H "Content-Type: application/json" \
+  -d '{"name":"alice"}' | jq -r .vpn_key
+```
+
+Имея `vpn_key`, конфиг `.conf` можно получить локально: убрать префикс `vpn://`,
+base64url-декодировать, отбросить первые 4 байта (длина), распаковать
+`zlib inflate` → JSON; текст конфига лежит в `last_config.config`.
+
+### Интерфейс AWG
+
+| Метод | Что делает |
+|---|---|
+| `POST /awg/start` | Поднимает интерфейс, если он лежит; возвращает его статус |
+| `POST /awg/restart` | `awg-quick down/up` + ресинк пиров, `{ "success": true }`. Соединения клиентов кратковременно рвутся |
+| `POST /awg/upgrade` | Переводит сервер с 2.0 на 3.1: правит `awg1.conf`, перезапускает интерфейс и перевыпускает все ключи. `{ gen, backup, bumpedS: [], reissue: { total, reissued, … } }` |
+
+`POST /awg/upgrade` отвечает `409`, если сервер уже на 3.1, модуль в ядре не
+3.x или ядро старше 5.5, и `500` с текстом причины, если ядро не приняло
+3.1-конфиг — в этом случае прежний конфиг возвращается из копии, а интерфейс
+поднимается обратно на 2.0.

-Сама панель и её API к домену не привязаны: работают по адресу того сервера,
-куда установлены, внешних сервисов не требуют.
 ## Управление

 ```bash
@@ -0,0 +1,67 @@
+# Admin — каркас админ-панели
+
+Самодостаточный шаблон админки: бэкенд с авторизацией и фронтенд-оболочка
+с системой вкладок. Предметной логики нет — это основа, поверх которой
+навешиваются свои роуты и вкладки.
+
+```
+admin/
+  backend/     Express: /login, /logout, JWT, rate-limit, отдача SPA
+    server.ts
+  frontend/    React 18 + Vite: логин, тема, drawer/сайдбар, реестр вкладок
+    src/App.tsx          оболочка
+    src/App.css          дизайн-система (Material 3, тёплая палитра)
+    src/tabs/            вкладки — см. src/tabs/README.md
+    src/components/      общие компоненты и иконки (+ карта ICONS)
+    src/lib/shared.ts    общие типы/утилиты + PageProps
+    src/lib/branding.ts  название и версия панели
+```
+
+## Запуск в деве
+
+Два терминала:
+
+```bash
+cd admin/backend  && npm install && ADMIN_PASS=admin npm start   # :8080
+cd admin/frontend && npm install && npm run dev                  # :5173
+```
+
+Открыть http://localhost:5173 — логин `admin` / `admin`.
+Vite проксирует `/api`, `/login`, `/logout` на бэкенд, поэтому фронт всегда
+ходит по относительным путям и порт нигде не зашит.
+
+## Прод
+
+```bash
+cd admin/frontend && npm run build     # → frontend/dist
+cd admin/backend  && npm start         # раздаёт dist и API с одного порта
+```
+
+## Переменные окружения (backend)
+
+| Переменная    | По умолчанию              | Смысл                                                        |
+|---------------|---------------------------|--------------------------------------------------------------|
+| `PORT`        | `8080`                    | Порт бэкенда                                                  |
+| `ADMIN_USER`  | `admin`                   | Логин в панель                                                |
+| `ADMIN_PASS`  | — (пусто ⇒ вход отключён) | Пароль; без него `/login` всегда отвечает 401                 |
+| `JWT_SECRET`  | случайный при старте      | Подпись токенов; без него сессии рвутся при рестарте процесса |
+| `STATIC_DIR`  | `../frontend/dist`        | Каталог со сборкой фронта                                     |
+
+## Авторизация
+
+`POST /login` (логин + пароль) → HS256 JWT на 24 часа, подписанный `JWT_SECRET`
+через встроенный `crypto` — без сторонних JWT-библиотек. Токен хранится в
+`localStorage` и уходит в заголовке `Authorization: Bearer`. `POST /logout`
+добавляет подпись токена в in-memory список отозванных — токен умирает сразу.
+Перебор пароля ограничен: 5 неудачных попыток с одного IP за 15 минут → 429.
+
+Всё под `/api` закрыто мидлварой `requireAuth` — свои роуты добавляй ниже
+строки `app.use("/api", requireAuth)` в `server.ts`, и они получают авторизацию
+даром. `GET /api/session` уже есть: фронт зовёт его при загрузке, чтобы понять,
+жив ли сохранённый токен.
+
+## Как добавить свой раздел
+
+1. Роут на бэкенде — в `server.ts` под `/api/…`.
+2. Вкладку на фронте — папка в `src/tabs/`, реестр подхватит её сам.
+   Подробности и формат `metadata.json` — в [src/tabs/README.md](frontend/src/tabs/README.md).
@@ -0,0 +1,19 @@
+{
+  "name": "admin-backend",
+  "version": "0.1.0",
+  "private": true,
+  "scripts": {
+    "start": "tsx server.ts",
+    "dev": "tsx watch server.ts",
+    "typecheck": "tsc --noEmit"
+  },
+  "dependencies": {
+    "express": "^4.19.0"
+  },
+  "devDependencies": {
+    "@types/express": "^4.17.0",
+    "@types/node": "^22.0.0",
+    "tsx": "^4.7.0",
+    "typescript": "^5.4.0"
+  }
+}
@@ -0,0 +1,131 @@
+// 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.
+// Бэкенд админ-панели: логин, JWT-сессия, отдача собранного SPA.
+// Никакой предметной логики здесь нет — это каркас, поверх которого
+// навешиваются свои роуты под /api (они автоматически за requireAuth).
+import express, { Request, Response, NextFunction } from "express";
+import path   from "path";
+import crypto from "crypto";
+
+const app  = express();
+const PORT = Number(process.env.PORT) || 8080;
+
+const ADMIN_USER = process.env.ADMIN_USER ?? "admin";
+const ADMIN_PASS = process.env.ADMIN_PASS ?? "";
+// Без заданного секрета токены живут только до рестарта процесса — для дева
+// это удобно, в проде JWT_SECRET обязателен (иначе сессии рвутся при рестарте).
+const JWT_SECRET = process.env.JWT_SECRET ?? crypto.randomBytes(32).toString("hex");
+
+// Каталог со сборкой фронта (vite build → frontend/dist).
+const STATIC_DIR = process.env.STATIC_DIR ?? path.join(__dirname, "..", "frontend", "dist");
+
+const TOKEN_TTL = 24 * 60 * 60; // сек
+
+// Отозванные токены (logout). In-memory: рестарт процесса и так рвёт сессии,
+// потому что при пустом JWT_SECRET секрет генерится заново.
+const revoked = new Set<string>();
+
+function tokenSig(token: string): string { return token.split(".")[2] ?? token; }
+
+function sign(user: string): string {
+    const h = Buffer.from('{"alg":"HS256","typ":"JWT"}').toString("base64url");
+    const p = Buffer.from(JSON.stringify({
+        sub: user,
+        exp: Math.floor(Date.now() / 1000) + TOKEN_TTL,
+    })).toString("base64url");
+    const s = crypto.createHmac("sha256", JWT_SECRET).update(`${h}.${p}`).digest("base64url");
+    return `${h}.${p}.${s}`;
+}
+
+interface Claims { sub?: string; exp: number; }
+
+function verify(token: string): Claims | null {
+    try {
+        if (revoked.has(tokenSig(token))) return null;
+        const [h, p, s] = token.split(".");
+        if (!h || !p || !s) return null;
+        const expected = crypto.createHmac("sha256", JWT_SECRET).update(`${h}.${p}`).digest();
+        const actual   = Buffer.from(s, "base64url");
+        if (actual.length !== expected.length) return null;
+        if (!crypto.timingSafeEqual(actual, expected)) return null;
+        const claims = JSON.parse(Buffer.from(p, "base64url").toString()) as Claims;
+        if (claims.exp <= Math.floor(Date.now() / 1000)) return null;
+        return claims;
+    } catch { return null; }
+}
+
+interface AuthRequest extends Request { claims?: Claims; }
+
+export function requireAuth(req: Request, res: Response, next: NextFunction) {
+    const auth  = (req.headers["authorization"] ?? "") as string;
+    const token = auth.startsWith("Bearer ") ? auth.slice(7) : "";
+    const claims = token ? verify(token) : null;
+    if (!claims) { res.status(401).json({ error: "Unauthorized" }); return; }
+    (req as AuthRequest).claims = claims;
+    next();
+}
+
+// Ограничение перебора пароля: 5 неудачных попыток на IP за 15 минут.
+const RATE_LIMIT  = 5;
+const RATE_WINDOW = 15 * 60 * 1000;
+
+interface RateEntry { count: number; resetAt: number; }
+const loginAttempts = new Map<string, RateEntry>();
+
+function checkRate(ip: string): { ok: boolean; retryAfter?: number } {
+    const now   = Date.now();
+    const entry = loginAttempts.get(ip);
+    if (!entry || entry.resetAt < now) {
+        loginAttempts.set(ip, { count: 1, resetAt: now + RATE_WINDOW });
+        return { ok: true };
+    }
+    if (entry.count >= RATE_LIMIT) {
+        return { ok: false, retryAfter: Math.ceil((entry.resetAt - now) / 1000) };
+    }
+    entry.count++;
+    return { ok: true };
+}
+
+app.use(express.json());
+
+app.post("/login", (req: Request, res: Response) => {
+    const ip = req.socket.remoteAddress ?? "unknown";
+    const { ok, retryAfter } = checkRate(ip);
+    if (!ok) {
+        res.status(429).json({ error: `Слишком много попыток. Повтори через ${retryAfter} сек.` }); return;
+    }
+    const { user, pass } = req.body as { user?: string; pass?: string };
+    if (!ADMIN_PASS || user !== ADMIN_USER || pass !== ADMIN_PASS) {
+        res.status(401).json({ error: "Неверный логин или пароль" }); return;
+    }
+    loginAttempts.delete(ip);
+    res.json({ token: sign(ADMIN_USER) });
+});
+
+app.post("/logout", requireAuth, (req: Request, res: Response) => {
+    const token = (req.headers["authorization"] as string).slice(7);
+    revoked.add(tokenSig(token));
+    res.json({ ok: true });
+});
+
+// Всё под /api закрыто JWT — свои роуты добавляй ниже этой строки.
+app.use("/api", requireAuth);
+
+// Проверка живости сессии: фронт зовёт его при загрузке, чтобы понять,
+// валиден ли сохранённый токен.
+app.get("/api/session", (req: Request, res: Response) => {
+    res.json({ user: (req as AuthRequest).claims?.sub ?? null });
+});
+
+// Статика SPA + fallback на index.html (роутинг на клиенте).
+app.use(express.static(STATIC_DIR));
+
+app.get("*", (_req: Request, res: Response) => {
+    res.sendFile(path.join(STATIC_DIR, "index.html"));
+});
+
+app.listen(PORT, () => {
+    if (!ADMIN_PASS) console.warn("admin: ADMIN_PASS не задан — вход отключён");
+    console.log(`admin: listening on :${PORT}`);
+});
@@ -0,0 +1,14 @@
+{
+  "compilerOptions": {
+    "target": "ES2020",
+    "lib": ["ES2020"],
+    "module": "CommonJS",
+    "moduleResolution": "node",
+    "strict": true,
+    "skipLibCheck": true,
+    "noEmit": true,
+    "esModuleInterop": true,
+    "resolveJsonModule": true
+  },
+  "include": ["server.ts"]
+}
@@ -0,0 +1,12 @@
+<!DOCTYPE html>
+<html lang="ru">
+  <head>
+    <meta charset="UTF-8" />
+    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
+    <title>Admin</title>
+  </head>
+  <body>
+    <div id="root"></div>
+    <script type="module" src="/src/main.tsx"></script>
+  </body>
+</html>
@@ -0,0 +1,24 @@
+{
+  "name": "admin-frontend",
+  "version": "0.1.0",
+  "private": true,
+  "scripts": {
+    "dev": "vite",
+    "build": "vite build",
+    "preview": "vite preview",
+    "typecheck": "tsc --noEmit"
+  },
+  "dependencies": {
+    "axios": "^1.7.0",
+    "react": "^18.3.0",
+    "react-dom": "^18.3.0"
+  },
+  "devDependencies": {
+    "@types/node": "^22.0.0",
+    "@types/react": "^18.3.0",
+    "@types/react-dom": "^18.3.0",
+    "@vitejs/plugin-react": "^4.3.0",
+    "typescript": "^5.4.0",
+    "vite": "^5.4.0"
+  }
+}
@@ -0,0 +1,554 @@
+/*
+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.
+
+Дизайн-система панели: тёплая кремовая база + прохладный фиолетовый акцент
+в ролях Material 3. Здесь только общий язык (палитра, кнопки, поля, чипы,
+таблица, модалка, снэкбар) — стили конкретной вкладки живут в её папке
+(tabs/<name>/<name>.css) и импортятся её же компонентом.
+*/
+*, *::before, *::after { box-sizing: border-box; margin: 0; padding: 0; }
+html, body, #root { height: 100%; }
+
+:root {
+    --primary:              #6a45b8;
+    --on-primary:           #ffffff;
+    --primary-container:    #ebddff;
+    --on-primary-container: #5a2da8;
+
+    --surface:              #faf6f0;
+    --surface-bright:       #fdfaf6;
+    --surface-container:    #f0e8dd;
+    --surface-hi:           #ece2d3;
+    --on-surface:           #3a2e22;
+
+    --outline:              #d8cdbe;
+    --outline-variant:      #ece2d3;
+
+    --success-bg:   #c0dd97; --success-text: #2c4d0a; --success-dot: #639922;
+    --neutral-bg:   #e4dac9; --neutral-text: #7a6a55; --neutral-dot:  #a99a85;
+    --error-bg:     #ffdad6; --error-text:   #410002; --error-dot:    #ba1a1a;
+
+    --danger-border: #e6c4bc;
+    --danger-text:   #b34a3a;
+
+    /* приглушённый «бровый» лейбл — заголовки таблицы, неактивная навигация */
+    --label: #5a4a3a;
+
+    /* state layers / тени — зависят от темы */
+    --state-primary: rgba(106, 69, 184, .10);
+    --state-row:     rgba(106, 69, 184, .035);
+    --state-neutral: rgba(58, 46, 34, .08);
+    --scrim:         rgba(58, 46, 34, .45);
+    --shadow:        rgba(58, 46, 34, .15);
+
+    --font:  system-ui, -apple-system, 'Inter', sans-serif;
+    --mono:  'JetBrains Mono', 'Fira Code', ui-monospace, monospace;
+
+    --r-pill:  100px;
+    --r-card:  24px;
+    --r-table: 16px;
+    --r-logo:  9px;
+}
+
+:root[data-theme="dark"] {
+    --primary:              #cbb3ff;
+    --on-primary:           #381b6c;
+    --primary-container:    #52389e;
+    --on-primary-container: #ebddff;
+
+    --surface:              #1a1611;
+    --surface-bright:       #2b251d;
+    --surface-container:    #251f18;
+    --surface-hi:           #302820;
+    --on-surface:           #ede2d4;
+
+    --outline:              #4d4334;
+    --outline-variant:      #342c20;
+
+    --success-bg:   #2d4413; --success-text: #c8e3a0; --success-dot: #8fc24f;
+    --neutral-bg:   #34291c; --neutral-text: #d0c0a4; --neutral-dot:  #b0a085;
+    --error-bg:     #5c1414; --error-text:   #ffb4ab; --error-dot:    #ff5449;
+
+    --danger-border: #6e4540;
+    --danger-text:   #ffb4ab;
+
+    --label: #b6a994;
+
+    --state-primary: rgba(203, 179, 255, .14);
+    --state-row:     rgba(203, 179, 255, .05);
+    --state-neutral: rgba(237, 226, 212, .08);
+    --scrim:         rgba(0, 0, 0, .55);
+    --shadow:        rgba(0, 0, 0, .45);
+}
+
+body {
+    font-family: var(--font);
+    font-size: 14px;
+    font-weight: 400;
+    color: var(--on-surface);
+    background: var(--surface);
+    -webkit-font-smoothing: antialiased;
+    transition: background 0.2s ease, color 0.2s ease;
+}
+
+.app { min-height: 100vh; display: flex; flex-direction: column; position: relative; }
+
+.logo-name { font-size: 17px; font-weight: 500; color: var(--on-surface); }
+
+.login-screen {
+    flex: 1;
+    display: flex;
+    align-items: center;
+    justify-content: center;
+    background: var(--surface);
+}
+.login-card {
+    width: 352px;
+    background: var(--surface-bright);
+    border-radius: var(--r-card);
+    border: 1px solid var(--outline-variant);
+    padding: 36px 32px 32px;
+    display: flex;
+    flex-direction: column;
+    gap: 12px;
+}
+.login-sub {
+    font-size: 14px;
+    color: var(--neutral-text);
+    margin-bottom: 4px;
+}
+.login-error {
+    font-size: 13px;
+    color: var(--danger-text);
+    text-align: center;
+}
+
+.field {
+    height: 44px;
+    padding: 0 16px;
+    border: 1.5px solid var(--outline);
+    border-radius: var(--r-pill);
+    background: var(--surface-bright);
+    font-family: var(--font);
+    font-size: 14px;
+    color: var(--on-surface);
+    outline: none;
+    transition: border-color 0.15s;
+    width: 100%;
+}
+.field:focus        { border-color: var(--primary); }
+.field::placeholder { color: var(--neutral-dot); }
+
+.btn {
+    display: inline-flex;
+    align-items: center;
+    justify-content: center;
+    gap: 6px;
+    height: 44px;
+    padding: 0 20px;
+    border-radius: var(--r-pill);
+    border: none;
+    font-family: var(--font);
+    font-size: 14px;
+    font-weight: 500;
+    cursor: pointer;
+    white-space: nowrap;
+    transition: opacity 0.12s, background 0.12s;
+    flex-shrink: 0;
+}
+.btn:hover  { opacity: 0.88; }
+.btn:active { opacity: 0.74; }
+
+.btn--primary { background: var(--primary); color: var(--on-primary); }
+.btn--tonal   { background: var(--primary-container); color: var(--on-primary-container); border: none; }
+.btn--outline {
+    background: transparent;
+    border: 1.5px solid var(--outline);
+    color: var(--primary);
+}
+.btn--danger {
+    background: transparent;
+    border: 1.5px solid var(--danger-border);
+    color: var(--danger-text);
+}
+.btn--full { width: 100%; }
+.btn--sq   { width: 44px; padding: 0; flex-shrink: 0; }
+
+/* icon-only circular button */
+.btn-icon {
+    width: 30px; height: 30px;
+    border-radius: 50%;
+    border: none;
+    background: transparent;
+    cursor: pointer;
+    display: inline-flex;
+    align-items: center;
+    justify-content: center;
+    color: var(--primary);
+    transition: background 0.12s;
+    flex-shrink: 0;
+}
+.btn-icon:hover          { background: var(--state-primary); }
+.btn-icon--danger        { color: var(--danger-text); }
+.btn-icon--danger:hover  { background: rgba(179,74,58,.10); }
+.btn-icon--neutral       { color: var(--neutral-text); }
+.btn-icon--neutral:hover { background: var(--state-neutral); }
+
+.theme-toggle {
+    position: fixed;
+    top: 16px;
+    right: 16px;
+    z-index: 250;
+    width: 40px;
+    height: 40px;
+    border-radius: 50%;
+    border: 1.5px solid var(--outline);
+    background: var(--surface-bright);
+    color: var(--on-surface);
+    display: inline-flex;
+    align-items: center;
+    justify-content: center;
+    cursor: pointer;
+    -webkit-tap-highlight-color: transparent;
+    transition: background 0.12s, border-color 0.12s, color 0.12s;
+}
+.theme-toggle:hover { border-color: var(--primary); color: var(--primary); }
+
+.top-bar {
+    display: none;
+    align-items: center;
+    gap: 4px;
+    height: 56px;
+    padding: 0 8px 0 4px;
+    background: var(--surface);
+    flex-shrink: 0;
+    z-index: 10;
+}
+.hamburger-btn {
+    width: 48px; height: 48px;
+    border: none;
+    background: transparent;
+    border-radius: 50%;
+    display: flex;
+    align-items: center;
+    justify-content: center;
+    cursor: pointer;
+    color: var(--on-surface);
+    flex-shrink: 0;
+    -webkit-tap-highlight-color: transparent;
+}
+.hamburger-btn:active { background: var(--state-neutral); }
+.top-bar-title {
+    font-size: 20px;
+    font-weight: 500;
+    color: var(--on-surface);
+}
+
+.drawer-scrim {
+    display: none;
+    position: fixed;
+    inset: 0;
+    background: var(--scrim);
+    z-index: 300;
+    opacity: 0;
+    pointer-events: none;
+    transition: opacity 0.27s cubic-bezier(0.2, 0, 0, 1);
+}
+.drawer-scrim--visible {
+    opacity: 1;
+    pointer-events: auto;
+}
+
+.layout {
+    flex: 1;
+    display: flex;
+    min-height: 100vh;
+}
+
+.sidebar {
+    width: 240px;
+    flex-shrink: 0;
+    background: var(--surface-container);
+    display: flex;
+    flex-direction: column;
+    padding: 24px 12px;
+    gap: 0;
+}
+.sidebar-logo {
+    padding: 0 8px 20px;
+    display: flex;
+    flex-direction: column;
+    gap: 2px;
+}
+.sidebar-version {
+    font-size: 11px;
+    color: var(--neutral-dot);
+    margin-top: 2px;
+}
+.drawer-divider {
+    border: none;
+    border-top: 0.5px solid var(--outline);
+    margin: 0 -12px 8px;
+}
+
+.nav-item {
+    display: flex;
+    align-items: center;
+    gap: 10px;
+    padding: 10px 12px;
+    border-radius: var(--r-pill);
+    font-size: 14px;
+    font-weight: 400;
+    color: var(--label);
+    cursor: default;
+    user-select: none;
+}
+.nav-item--active {
+    background: var(--primary-container);
+    color: var(--on-primary-container);
+    font-weight: 500;
+}
+
+.sidebar-spacer { flex: 1; }
+
+.chip {
+    display: inline-flex;
+    align-items: center;
+    gap: 6px;
+    padding: 4px 10px;
+    border-radius: var(--r-pill);
+    font-size: 12px;
+    white-space: nowrap;
+}
+.chip-dot {
+    width: 6px; height: 6px;
+    border-radius: 50%;
+    flex-shrink: 0;
+}
+.chip--online  { background: var(--success-bg); color: var(--success-text); }
+.chip--online  .chip-dot { background: var(--success-dot); }
+.chip--offline { background: var(--neutral-bg); color: var(--neutral-text); }
+.chip--offline .chip-dot { background: var(--neutral-dot); }
+
+.main {
+    flex: 1;
+    padding: 32px 36px;
+    display: flex;
+    flex-direction: column;
+    gap: 20px;
+    overflow: auto;
+    min-width: 0;
+}
+.page-title {
+    font-size: 20px;
+    font-weight: 500;
+    color: var(--on-surface);
+}
+
+/* Заглушка на месте контента — когда вкладок ещё нет */
+.placeholder {
+    color: var(--neutral-text);
+    font-size: 14px;
+}
+.placeholder code {
+    font-family: var(--mono);
+    font-size: 13px;
+    background: var(--surface-container);
+    padding: 2px 6px;
+    border-radius: 6px;
+}
+
+/* Тултип без задержки: нативный title браузер показывает через ~500 мс */
+.tip-wrap {
+    position: relative;
+    display: inline-flex;
+}
+.tip-wrap::after {
+    content: attr(data-tip);
+    position: absolute;
+    bottom: calc(100% + 7px);
+    left: 50%;
+    transform: translateX(-50%);
+    background: var(--on-surface);
+    color: var(--surface-bright);
+    font-size: 12px;
+    white-space: nowrap;
+    padding: 5px 12px;
+    border-radius: var(--r-pill);
+    pointer-events: none;
+    opacity: 0;
+    transition: opacity 0.12s;
+}
+.tip-wrap:hover::after { opacity: 1; }
+
+.toolbar {
+    display: flex;
+    align-items: center;
+    gap: 10px;
+    flex-wrap: wrap;
+}
+.toolbar .field {
+    width: 224px;
+    height: 44px;
+    flex-shrink: 0;
+}
+/* На десктопе кнопки участвуют в flex toolbar'а напрямую */
+.toolbar-btns { display: contents; }
+
+.table-card {
+    background: var(--surface-bright);
+    border-radius: var(--r-table);
+    border: 1px solid var(--outline-variant);
+    overflow: hidden;
+}
+table {
+    width: 100%;
+    border-collapse: collapse;
+}
+thead th {
+    background: var(--surface-container);
+    color: var(--label);
+    font-weight: 500;
+    font-size: 13px;
+    text-align: left;
+    padding: 11px 14px;
+}
+thead th:first-child { padding-left: 20px; }
+thead th:last-child  { padding-right: 20px; }
+
+tbody tr { border-top: 0.5px solid var(--outline-variant); }
+tbody tr:hover { background: var(--state-row); }
+
+tbody td {
+    padding: 11px 14px;
+    font-size: 13px;
+    color: var(--on-surface);
+    vertical-align: middle;
+}
+tbody td:first-child { padding-left: 20px; }
+tbody td:last-child  { padding-right: 20px; }
+
+.td-num  { font-size: 12px; color: var(--neutral-dot); width: 32px; }
+.td-mono { font-family: var(--mono); font-size: 12px; }
+.td-actions { width: 96px; }
+
+.actions { display: flex; align-items: center; gap: 2px; }
+
+.empty {
+    text-align: center;
+    color: var(--neutral-text);
+    padding: 48px 0 !important;
+    font-size: 14px;
+}
+
+/* Модалка — общий каркас (backdrop + карточка). Содержимое даёт вкладка. */
+@keyframes backdrop-in {
+    from { opacity: 0; }
+    to   { opacity: 1; }
+}
+@keyframes card-in {
+    from { opacity: 0; transform: scale(.92) translateY(12px); }
+    to   { opacity: 1; transform: scale(1)   translateY(0); }
+}
+
+.modal-backdrop {
+    position: fixed; inset: 0;
+    background: var(--scrim);
+    display: flex; align-items: center; justify-content: center;
+    z-index: 300;
+    animation: backdrop-in 0.18s ease;
+}
+.modal-card {
+    background: var(--surface-bright);
+    border-radius: var(--r-card);
+    border: 1px solid var(--outline-variant);
+    padding: 28px 28px 24px;
+    display: flex; flex-direction: column; align-items: center; gap: 14px;
+    width: 320px;
+    animation: card-in 0.22s cubic-bezier(.34,1.26,.64,1);
+}
+.modal-title   { font-size: 16px; font-weight: 500; color: var(--on-surface); }
+.modal-hint    { font-size: 12px; color: var(--neutral-text); text-align: center; }
+.modal-actions { display: flex; gap: 8px; width: 100%; }
+.modal-actions .btn { flex: 1; }
+
+.snack {
+    position: fixed;
+    bottom: 28px;
+    left: 50%;
+    transform: translateX(-50%);
+    background: var(--on-surface);
+    color: var(--surface-bright);
+    font-size: 13px;
+    padding: 10px 22px;
+    border-radius: var(--r-pill);
+    z-index: 500;
+    white-space: nowrap;
+    pointer-events: none;
+    box-shadow: 0 4px 16px var(--shadow);
+}
+
+@media (max-width: 640px) {
+    /* Top bar */
+    .top-bar     { display: flex; }
+    .page-title  { display: none; }
+
+    /* Drawer scrim */
+    .drawer-scrim { display: block; }
+
+    /* Запретить горизонтальный скролл страницы */
+    body, .app { overflow-x: hidden; }
+
+    /* Sidebar → модальный drawer */
+    .layout {
+        min-height: 0; /* flex: 1 на .app справится сам */
+        overflow: visible;
+    }
+    /* main — не скролл-контейнер, пусть скроллит body */
+    .main { overflow: visible; }
+
+    .sidebar {
+        position: fixed;
+        top: 0; left: 0;
+        height: 100%;
+        width: 280px;
+        z-index: 400;
+        border-radius: 0 var(--r-card) var(--r-card) 0;
+        transform: translateX(-100%);
+        transition: transform 0.27s cubic-bezier(0.2, 0, 0, 1);
+        box-shadow: 4px 0 24px var(--shadow);
+        padding-top: 36px;
+    }
+    .sidebar--open { transform: translateX(0); }
+
+    /* Main: одна колонка, поля 16px */
+    .main {
+        padding: 16px;
+        gap: 12px;
+    }
+
+    /* Toolbar → вертикально */
+    .toolbar {
+        flex-direction: column;
+        align-items: stretch;
+        gap: 8px;
+    }
+    .toolbar .field { width: 100%; }
+    .toolbar-btns {
+        display: flex;
+        gap: 8px;
+    }
+    .toolbar-btns .btn { flex: 1; }
+
+    /* Таблицы на мобильном заменяются карточками — их даёт сама вкладка */
+    .table-card { display: none; }
+
+    /* Модалка — по ширине экрана */
+    .modal-card {
+        width: calc(100vw - 32px);
+        max-width: 360px;
+        padding: 24px 20px 20px;
+    }
+}
@@ -0,0 +1,211 @@
+// 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, useRef, useCallback } from 'react';
+import axios from 'axios';
+import './App.css';
+import { TOKEN_KEY, THEME_KEY } from './lib/shared';
+import { APP_NAME, APP_VERSION } from './lib/branding';
+import { IcoMenu, IcoLogout, IcoSun, IcoMoon } from './components/icons';
+import { TABS } from './tabs';
+
+// Оболочка приложения: логин, тема, drawer/сайдбар, общая сессия (token,
+// снэкбар) и переключение вкладок. Контент каждой вкладки приходит из реестра
+// TABS — App про конкретные вкладки ничего не знает.
+export default function App() {
+    const [token, setToken]           = useState(() => localStorage.getItem(TOKEN_KEY) ?? '');
+    const [loginUser, setLoginUser]   = useState('');
+    const [loginPass, setLoginPass]   = useState('');
+    const [loginError, setLoginError] = useState('');
+    const [msg, setMsg]               = useState('');
+    const [drawerOpen, setDrawerOpen] = useState(false);
+    const [activeTab, setActiveTab]   = useState(() => TABS[0]?.id ?? '');
+    const [theme, setTheme]           = useState<'light' | 'dark'>(() =>
+        localStorage.getItem(THEME_KEY) === 'dark' ? 'dark' : 'light');
+    const touchStartX                 = useRef(0);
+    const touchCurrentX               = useRef(0);
+
+    const showMsg = useCallback((text: string) => {
+        setMsg(text);
+        setTimeout(() => setMsg(''), 3000);
+    }, []);
+
+    // Проверяет, жив ли токен. Данные конкретных вкладок грузят сами вкладки.
+    const startSession = useCallback(async (tok: string) => {
+        await axios.get('/api/session', { headers: { Authorization: `Bearer ${tok}` } });
+    }, []);
+
+    const login = useCallback(async () => {
+        try {
+            const { data: auth } = await axios.post('/login', { user: loginUser, pass: loginPass });
+            const tok = auth.token as string;
+            await startSession(tok);
+            localStorage.setItem(TOKEN_KEY, tok);
+            setLoginError('');
+            setToken(tok);
+        } catch (e) {
+            if (axios.isAxiosError(e) && e.response?.status === 401) {
+                showMsg('Неверный логин или пароль');
+            } else if (axios.isAxiosError(e) && e.response?.status === 429) {
+                showMsg(e.response.data?.error ?? 'Слишком много попыток');
+            } else {
+                setLoginError('Сервер недоступен');
+            }
+        }
+    }, [loginUser, loginPass, startSession, showMsg]);
+
+    const logout = useCallback(async () => {
+        try {
+            await axios.post('/logout', null, { headers: { Authorization: `Bearer ${token}` } });
+        } catch { /* токен уже мог истечь */ }
+        localStorage.removeItem(TOKEN_KEY);
+        setToken('');
+        setDrawerOpen(false);
+    }, [token]);
+
+    const handleTouchStart = useCallback((e: React.TouchEvent) => {
+        touchStartX.current   = e.touches[0].clientX;
+        touchCurrentX.current = e.touches[0].clientX;
+    }, []);
+    const handleTouchMove = useCallback((e: React.TouchEvent) => {
+        touchCurrentX.current = e.touches[0].clientX;
+    }, []);
+    const handleTouchEnd = useCallback(() => {
+        if (touchStartX.current - touchCurrentX.current > 40) setDrawerOpen(false);
+    }, []);
+
+    // Восстановить сессию из сохранённого токена
+    useEffect(() => {
+        const saved = localStorage.getItem(TOKEN_KEY);
+        if (saved) {
+            startSession(saved).catch(() => {
+                localStorage.removeItem(TOKEN_KEY);
+                setToken('');
+            });
+        }
+    }, [startSession]);
+
+    // Применять и сохранять тему
+    useEffect(() => {
+        document.documentElement.setAttribute('data-theme', theme);
+        localStorage.setItem(THEME_KEY, theme);
+    }, [theme]);
+
+    // Блокировать прокрутку фона когда drawer открыт
+    useEffect(() => {
+        document.body.style.overflow = drawerOpen ? 'hidden' : '';
+        return () => { document.body.style.overflow = ''; };
+    }, [drawerOpen]);
+
+    // Закрывать drawer по Escape
+    useEffect(() => {
+        if (!drawerOpen) return;
+        const h = (e: KeyboardEvent) => { if (e.key === 'Escape') setDrawerOpen(false); };
+        document.addEventListener('keydown', h);
+        return () => document.removeEventListener('keydown', h);
+    }, [drawerOpen]);
+
+    // Вкладок может не быть вовсе — тогда вместо контента показываем заглушку.
+    const tab = TABS.find(t => t.id === activeTab) ?? TABS[0] ?? null;
+
+    return (
+        <div className="app">
+            <button
+                className="theme-toggle"
+                aria-label={theme === 'dark' ? 'Светлая тема' : 'Тёмная тема'}
+                onClick={() => setTheme(t => (t === 'dark' ? 'light' : 'dark'))}
+            >
+                {theme === 'dark' ? <IcoSun /> : <IcoMoon />}
+            </button>
+
+            {!token ? (
+                <div className="login-screen">
+                    <div className="login-card">
+                        <span className="logo-name">{APP_NAME}</span>
+                        <p className="login-sub">Войдите, чтобы продолжить</p>
+                        <input
+                            className="field"
+                            placeholder="Логин"
+                            value={loginUser}
+                            onChange={e => setLoginUser(e.target.value)}
+                            autoFocus
+                        />
+                        <input
+                            className="field"
+                            type="password"
+                            placeholder="Пароль"
+                            value={loginPass}
+                            onChange={e => setLoginPass(e.target.value)}
+                            onKeyDown={e => e.key === 'Enter' && login()}
+                        />
+                        <button className="btn btn--primary btn--full" onClick={login}>
+                            Войти
+                        </button>
+                        {loginError && <p className="login-error">{loginError}</p>}
+                    </div>
+                </div>
+            ) : (
+                <>
+                    {/* Top bar — видим только на мобильном */}
+                    <header className="top-bar">
+                        <button
+                            className="hamburger-btn"
+                            aria-label="Открыть меню"
+                            onClick={() => setDrawerOpen(true)}
+                        >
+                            <IcoMenu />
+                        </button>
+                        <span className="top-bar-title">{tab?.label ?? APP_NAME}</span>
+                    </header>
+
+                    {/* Затемнение под drawer */}
+                    <div
+                        className={`drawer-scrim${drawerOpen ? ' drawer-scrim--visible' : ''}`}
+                        onClick={() => setDrawerOpen(false)}
+                    />
+
+                    <div className="layout">
+                        <aside
+                            className={`sidebar${drawerOpen ? ' sidebar--open' : ''}`}
+                            onTouchStart={handleTouchStart}
+                            onTouchMove={handleTouchMove}
+                            onTouchEnd={handleTouchEnd}
+                        >
+                            <div className="sidebar-logo">
+                                <span className="logo-name">{APP_NAME}</span>
+                                <span className="sidebar-version">{APP_VERSION}</span>
+                            </div>
+                            <hr className="drawer-divider" />
+                            {TABS.map(t => (
+                                <div
+                                    key={t.id}
+                                    className={`nav-item${t.id === tab?.id ? ' nav-item--active' : ''}`}
+                                    onClick={() => { setActiveTab(t.id); setDrawerOpen(false); }}
+                                >
+                                    <t.Icon /> {t.label}
+                                </div>
+                            ))}
+
+                            <div className="sidebar-spacer" />
+
+                            <button className="btn btn--danger" onClick={logout}>
+                                <IcoLogout /> Выйти
+                            </button>
+                        </aside>
+
+                        <main className="main">
+                            <h2 className="page-title">{tab?.label ?? APP_NAME}</h2>
+                            {tab
+                                ? <tab.Page token={token} showMsg={showMsg} />
+                                : <p className="placeholder">
+                                      Вкладок пока нет — добавь папку в <code>src/tabs/</code>
+                                  </p>}
+                        </main>
+                    </div>
+                </>
+            )}
+
+            {msg && <div className="snack">{msg}</div>}
+        </div>
+    );
+}
@@ -0,0 +1,90 @@
+// 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.
+// Иконки интерфейса (inline SVG, currentColor). Добавляя вкладку — добавь сюда
+// её иконку и зарегистрируй имя в ICONS (его указывают в tabs/<name>/metadata.json).
+
+export const IcoMenu = () => (
+    <svg width="20" height="20" viewBox="0 0 24 24" fill="none" stroke="currentColor" strokeWidth="2" strokeLinecap="round">
+        <line x1="3" y1="6" x2="21" y2="6"/>
+        <line x1="3" y1="12" x2="21" y2="12"/>
+        <line x1="3" y1="18" x2="21" y2="18"/>
+    </svg>
+);
+export const IcoUsers = () => (
+    <svg width="16" height="16" viewBox="0 0 24 24" fill="none" stroke="currentColor" strokeWidth="2">
+        <path d="M17 21v-2a4 4 0 0 0-4-4H5a4 4 0 0 0-4 4v2"/>
+        <circle cx="9" cy="7" r="4"/>
+        <path d="M23 21v-2a4 4 0 0 0-3-3.87"/><path d="M16 3.13a4 4 0 0 1 0 7.75"/>
+    </svg>
+);
+export const IcoKey = () => (
+    <svg width="16" height="16" viewBox="0 0 24 24" fill="none" stroke="currentColor" strokeWidth="2" strokeLinecap="round" strokeLinejoin="round">
+        <circle cx="7.5" cy="15.5" r="4.5"/>
+        <path d="M10.7 12.3 21 2"/><path d="M16 7l3 3"/><path d="M18 5l2 2"/>
+    </svg>
+);
+export const IcoSettings = () => (
+    <svg width="16" height="16" viewBox="0 0 24 24" fill="none" stroke="currentColor" strokeWidth="2" strokeLinecap="round" strokeLinejoin="round">
+        <circle cx="12" cy="12" r="3"/>
+        <path d="M19.4 15a1.65 1.65 0 0 0 .33 1.82l.06.06a2 2 0 1 1-2.83 2.83l-.06-.06a1.65 1.65 0 0 0-1.82-.33 1.65 1.65 0 0 0-1 1.51V21a2 2 0 0 1-4 0v-.09a1.65 1.65 0 0 0-1.08-1.51 1.65 1.65 0 0 0-1.82.33l-.06.06a2 2 0 1 1-2.83-2.83l.06-.06a1.65 1.65 0 0 0 .33-1.82 1.65 1.65 0 0 0-1.51-1H3a2 2 0 0 1 0-4h.09A1.65 1.65 0 0 0 4.6 9a1.65 1.65 0 0 0-.33-1.82l-.06-.06a2 2 0 1 1 2.83-2.83l.06.06a1.65 1.65 0 0 0 1.82.33H9a1.65 1.65 0 0 0 1-1.51V3a2 2 0 0 1 4 0v.09a1.65 1.65 0 0 0 1 1.51 1.65 1.65 0 0 0 1.82-.33l.06-.06a2 2 0 1 1 2.83 2.83l-.06.06a1.65 1.65 0 0 0-.33 1.82V9a1.65 1.65 0 0 0 1.51 1H21a2 2 0 0 1 0 4h-.09a1.65 1.65 0 0 0-1.51 1z"/>
+    </svg>
+);
+export const IcoPlus = () => (
+    <svg width="14" height="14" viewBox="0 0 24 24" fill="none" stroke="currentColor" strokeWidth="2.5">
+        <line x1="12" y1="5" x2="12" y2="19"/><line x1="5" y1="12" x2="19" y2="12"/>
+    </svg>
+);
+export const IcoRefresh = () => (
+    <svg width="14" height="14" viewBox="0 0 24 24" fill="none" stroke="currentColor" strokeWidth="2">
+        <polyline points="23 4 23 10 17 10"/>
+        <path d="M20.49 15a9 9 0 1 1-2.12-9.36L23 10"/>
+    </svg>
+);
+export const IcoTrash = () => (
+    <svg width="15" height="15" viewBox="0 0 24 24" fill="none" stroke="currentColor" strokeWidth="2">
+        <polyline points="3 6 5 6 21 6"/>
+        <path d="M19 6l-1 14a2 2 0 0 1-2 2H8a2 2 0 0 1-2-2L5 6"/>
+        <path d="M10 11v6M14 11v6M9 6V4h6v2"/>
+    </svg>
+);
+export const IcoLogout = () => (
+    <svg width="15" height="15" viewBox="0 0 24 24" fill="none" stroke="currentColor" strokeWidth="2">
+        <path d="M9 21H5a2 2 0 0 1-2-2V5a2 2 0 0 1 2-2h4"/>
+        <polyline points="16 17 21 12 16 7"/>
+        <line x1="21" y1="12" x2="9" y2="12"/>
+    </svg>
+);
+export const IcoGlobe = () => (
+    <svg width="14" height="14" viewBox="0 0 24 24" fill="none" stroke="currentColor" strokeWidth="2" strokeLinecap="round" strokeLinejoin="round">
+        <circle cx="12" cy="12" r="10"/>
+        <line x1="2" y1="12" x2="22" y2="12"/>
+        <path d="M12 2a15.3 15.3 0 0 1 4 10 15.3 15.3 0 0 1-4 10 15.3 15.3 0 0 1-4-10 15.3 15.3 0 0 1 4-10z"/>
+    </svg>
+);
+export const IcoCopy = () => (
+    <svg width="14" height="14" viewBox="0 0 24 24" fill="none" stroke="currentColor" strokeWidth="2" strokeLinecap="round" strokeLinejoin="round">
+        <rect x="9" y="9" width="13" height="13" rx="2"/>
+        <path d="M5 15H4a2 2 0 0 1-2-2V4a2 2 0 0 1 2-2h9a2 2 0 0 1 2 2v1"/>
+    </svg>
+);
+export const IcoSun = () => (
+    <svg width="18" height="18" viewBox="0 0 24 24" fill="none" stroke="currentColor" strokeWidth="2" strokeLinecap="round" strokeLinejoin="round">
+        <circle cx="12" cy="12" r="4"/>
+        <path d="M12 2v2M12 20v2M4.93 4.93l1.41 1.41M17.66 17.66l1.41 1.41M2 12h2M20 12h2M4.93 19.07l1.41-1.41M17.66 6.34l1.41-1.41"/>
+    </svg>
+);
+export const IcoMoon = () => (
+    <svg width="18" height="18" viewBox="0 0 24 24" fill="none" stroke="currentColor" strokeWidth="2" strokeLinecap="round" strokeLinejoin="round">
+        <path d="M21 12.79A9 9 0 1 1 11.21 3 7 7 0 0 0 21 12.79z"/>
+    </svg>
+);
+
+// Карта «имя → иконка» для вкладок: metadata.json хранит имя строкой, реестр
+// (tabs/index.ts) резолвит его сюда. Новой вкладке — добавь сюда её иконку.
+export const ICONS: Record<string, () => JSX.Element> = {
+    users:    IcoUsers,
+    key:      IcoKey,
+    settings: IcoSettings,
+    globe:    IcoGlobe,
+};
@@ -0,0 +1,7 @@
+// 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.
+// Название и версия панели — показываются в шапке сайдбара и на экране логина.
+// Единственное место, где зашито «имя продукта»: под свой проект правится тут.
+export const APP_NAME    = 'Admin';
+export const APP_VERSION = 'Alpha 0.1.0';
@@ -0,0 +1,62 @@
+// 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 axios from 'axios';
+
+// Пропсы, которые оболочка передаёт каждой вкладке. Всё остальное (свои данные,
+// свой стейт) вкладка берёт сама.
+export interface PageProps {
+    token:   string;
+    showMsg: (text: string) => void;
+}
+
+export const TOKEN_KEY = 'admin_token';
+export const THEME_KEY = 'admin_theme';
+
+export async function apiFetch(method: string, path: string, token: string, body?: object): Promise<any> {
+    const r = await axios({ method, url: path, headers: { Authorization: `Bearer ${token}` }, data: body });
+    return r.data;
+}
+
+export function downloadFile(filename: string, text: string) {
+    const url = URL.createObjectURL(new Blob([text], { type: 'text/plain;charset=utf-8' }));
+    const a   = document.createElement('a');
+    a.href    = url;
+    a.download = filename;
+    document.body.appendChild(a);
+    a.click();
+    a.remove();
+    URL.revokeObjectURL(url);
+}
+
+export async function copyText(text: string) {
+    if (navigator.clipboard) {
+        await navigator.clipboard.writeText(text);
+    } else {
+        const ta = document.createElement('textarea');
+        ta.value = text;
+        ta.style.cssText = 'position:fixed;opacity:0';
+        document.body.appendChild(ta);
+        ta.select();
+        document.execCommand('copy');
+        document.body.removeChild(ta);
+    }
+}
+
+export function bytes(n: number | undefined): string {
+    if (!n) return '—';
+    if (n < 1024)          return n + ' B';
+    if (n < 1_048_576)     return (n / 1024).toFixed(1) + ' KB';
+    if (n < 1_073_741_824) return (n / 1_048_576).toFixed(1) + ' MB';
+    return (n / 1_073_741_824).toFixed(2) + ' GB';
+}
+
+// unix-секунды → «5 мин» / «3 ч» (без суффикса «назад» — его добавляет вызывающий)
+export function timeAgo(ts: number | undefined): string {
+    if (!ts) return '—';
+    const sec = Math.floor(Date.now() / 1000) - ts;
+    if (sec < 60)   return sec + ' сек';
+    if (sec < 3600) return Math.floor(sec / 60) + ' мин';
+    return Math.floor(sec / 3600) + ' ч';
+}
@@ -0,0 +1,12 @@
+// 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 { StrictMode } from 'react';
+import { createRoot } from 'react-dom/client';
+import App from './App';
+
+createRoot(document.getElementById('root')!).render(
+    <StrictMode>
+        <App />
+    </StrictMode>
+);
@@ -0,0 +1,34 @@
+# Вкладки
+
+Вкладок пока нет — каркас работает и с пустой папкой (оболочка покажет заглушку).
+
+## Как добавить вкладку
+
+Создай папку `src/tabs/<name>/` с тремя файлами — реестр (`tabs/index.ts`)
+подхватит её сам, править его **не нужно**.
+
+```
+src/tabs/reports/
+  metadata.json    { "id": "reports", "label": "Отчёты", "icon": "settings", "order": 1 }
+  index.tsx        export default function ReportsPage({ token, showMsg }: PageProps) { … }
+  reports.css      стили только этой вкладки (импортит сам index.tsx)
+```
+
+**metadata.json**
+
+| поле    | тип    | обяз. | смысл                                              |
+|---------|--------|-------|----------------------------------------------------|
+| `id`    | string | да    | ключ активной вкладки, должен быть уникальным       |
+| `label` | string | да    | подпись в меню и заголовок раздела                  |
+| `icon`  | string | да    | имя из `ICONS` в `src/components/icons.tsx`         |
+| `order` | number | нет   | порядок в меню по возрастанию (без него — 0)        |
+
+Манифест валидируется в рантайме: опечатка или незарегистрированная иконка
+падают с внятной ошибкой при сборке `TABS`, а не «тихо» в UI.
+
+**index.tsx** — дефолтный экспорт компонента `ComponentType<PageProps>`,
+где `PageProps = { token, showMsg }` (`src/lib/shared.ts`). Данные вкладка
+грузит сама: `apiFetch('GET', '/api/…', token)`.
+
+Новую иконку сначала добавь в `src/components/icons.tsx` и зарегистрируй
+в карте `ICONS` — на её имя и ссылается `metadata.json`.
@@ -0,0 +1,81 @@
+// 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.
+// Автообнаружение вкладок. Каждая вкладка — самодостаточная папка tabs/<name>/:
+//   index.tsx      — компонент + логика
+//   <name>.css     — стили вкладки (импортит сам компонент)
+//   metadata.json  — { id, label, icon, order? } (манифест: описание + порядок)
+// Реестр сам находит все папки через import.meta.glob и собирает «живые» части
+// (Page-компонент, Icon по имени из ICONS) к метадате. Добавить вкладку = просто
+// создать папку с index.tsx и metadata.json — этот файл трогать НЕ нужно.
+//   metadata.json НЕ проверяется компилятором (это JSON), поэтому содержимое
+//   валидируется здесь в рантайме — кривой/неполный манифест падает с внятной
+//   ошибкой при сборке TABS, а не «тихо» в UI.
+import type { ComponentType } from 'react';
+import type { PageProps } from '../lib/shared';
+import { ICONS } from '../components/icons';
+
+// Сериализуемая часть из metadata.json.
+export interface TabMeta {
+    id:     string;
+    label:  string;
+    icon:   string;     // имя иконки → ICONS
+    order?: number;     // порядок в меню (по возрастанию; без него — 0)
+}
+
+// Собранная вкладка: метадата + резолвнутые Icon и Page.
+export interface TabDef extends TabMeta {
+    Icon: () => JSX.Element;
+    Page: ComponentType<PageProps>;
+}
+
+const metas = import.meta.glob<{ default: unknown }>('./*/metadata.json', { eager: true });
+const pages = import.meta.glob<{ default: ComponentType<PageProps> }>('./*/index.tsx', { eager: true });
+
+// './users/metadata.json' → 'users'
+const folderOf = (path: string) => path.split('/')[1];
+
+// Валидация сырого metadata.json → типизированный TabMeta (или внятная ошибка).
+function toMeta(name: string, raw: unknown): TabMeta {
+    const m = (raw ?? {}) as Record<string, unknown>;
+    const str = (key: string): string => {
+        const v = m[key];
+        if (typeof v !== 'string' || v.trim() === '') {
+            throw new Error(`tabs/${name}/metadata.json: поле "${key}" должно быть непустой строкой`);
+        }
+        return v;
+    };
+    if (m.order !== undefined && typeof m.order !== 'number') {
+        throw new Error(`tabs/${name}/metadata.json: "order" должно быть числом`);
+    }
+    return {
+        id:    str('id'),
+        label: str('label'),
+        icon:  str('icon'),
+        order: m.order as number | undefined,
+    };
+}
+
+// Вкладок может не быть вовсе (чистый каркас) — тогда TABS пустой, и оболочка
+// показывает заглушку вместо контента.
+export const TABS: TabDef[] = Object.entries(metas)
+    .map(([path, mod]) => {
+        const name = folderOf(path);
+        const meta = toMeta(name, mod.default);
+        const page = pages[`./${name}/index.tsx`]?.default;
+        if (!page) {
+            throw new Error(`tabs/${name}: нет index.tsx рядом с metadata.json`);
+        }
+        if (!ICONS[meta.icon]) {
+            throw new Error(`tabs/${name}: иконка "${meta.icon}" не зарегистрирована в ICONS (components/icons.tsx)`);
+        }
+        return { ...meta, Icon: ICONS[meta.icon], Page: page };
+    })
+    .sort((a, b) => (a.order ?? 0) - (b.order ?? 0));
+
+// id вкладок используются как ключ активной вкладки — дубли ломают переключение.
+const ids = TABS.map(t => t.id);
+const dup = ids.find((id, i) => ids.indexOf(id) !== i);
+if (dup) {
+    throw new Error(`tabs: дублирующийся id "${dup}" — id вкладок должны быть уникальны`);
+}
@@ -0,0 +1,4 @@
+// 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.
+/// <reference types="vite/client" />
@@ -0,0 +1,15 @@
+{
+  "compilerOptions": {
+    "target": "ES2020",
+    "lib": ["ES2020", "DOM", "DOM.Iterable"],
+    "module": "ESNext",
+    "moduleResolution": "bundler",
+    "jsx": "react-jsx",
+    "strict": true,
+    "skipLibCheck": true,
+    "noEmit": true,
+    "esModuleInterop": true,
+    "resolveJsonModule": true
+  },
+  "include": ["src", "vite.config.ts"]
+}
@@ -0,0 +1,18 @@
+// 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 { defineConfig } from 'vite';
+import react from '@vitejs/plugin-react';
+
+// В деве Vite (:5173) проксирует запросы на бэкенд (:8080) — фронт всегда
+// ходит по относительным путям, порт нигде не зашит.
+export default defineConfig({
+    plugins: [react()],
+    server: {
+        proxy: {
+            '/api':    'http://localhost:8080',
+            '/login':  'http://localhost:8080',
+            '/logout': 'http://localhost:8080',
+        },
+    },
+});
@@ -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.
+//
+// Агент ноды. Сам открывает исходящее WSS-соединение к core (awg-ui), доказывает
+// свою личность подписью Ed25519 и исполняет присланные запросы на локальном
+// awg-ctrl (127.0.0.1). Входящих портов у ноды нет, awg-ctrl остаётся закрытым от сети.
+// Протокол и формат join-строки — docs/node-protocol.md.
+import crypto from "crypto";
+import fs from "fs";
+import path from "path";
+import type { TLSSocket } from "tls";
+import axios from "axios";
+import WebSocket from "ws";
+
+const CORE_HOST = process.env.CORE_HOST ?? "";
+const CORE_PORT = Number(process.env.CORE_PORT) || 0;
+const CORE_PIN  = process.env.CORE_PIN  ?? "";                 // SHA-256 SPKI сертификата core, base64url
+const NODE_ID   = Number(process.env.NODE_ID) || 0;
+const CTRL      = `http://127.0.0.1:${process.env.AWGCTRL_PORT ?? "3005"}`;
+const NODE_KEY_FILE = process.env.NODE_KEY_FILE ?? path.join(__dirname, "node.key");
+const INTERNAL_AUTH_KEY_FILE = process.env.INTERNAL_AUTH_KEY_FILE ?? "/etc/amnezia/amneziawg/internal_auth_private.key";
+const CLI_ENV_FILE = process.env.CLI_ENV_FILE ?? "";
+let joinSecret = process.env.JOIN_SECRET ?? "";                // одноразовый, живёт до первого успешного подключения
+
+if (!CORE_HOST || !CORE_PORT || !CORE_PIN || !NODE_ID) {
+    console.error("agent: не заданы CORE_HOST / CORE_PORT / CORE_PIN / NODE_ID — выполните `awg-ctrl join <ссылка>`");
+    process.exit(1);
+}
+
+// ── Ключи ──────────────────────────────────────────────────────────────────
+// Личность ноды (Ed25519): создаётся один раз, приватная часть с ноды не уходит.
+function loadNodeKey(): crypto.KeyObject {
+    if (!fs.existsSync(NODE_KEY_FILE)) {
+        const { privateKey } = crypto.generateKeyPairSync("ed25519");
+        fs.writeFileSync(NODE_KEY_FILE, privateKey.export({ type: "pkcs8", format: "pem" }), { mode: 0o600 });
+        console.log("agent: создан ключ ноды " + NODE_KEY_FILE);
+    }
+    return crypto.createPrivateKey(fs.readFileSync(NODE_KEY_FILE));
+}
+const nodeKey = loadNodeKey();
+const nodePubRaw = (() => {
+    const der = crypto.createPublicKey(nodeKey).export({ type: "spki", format: "der" }) as Buffer;
+    return der.subarray(der.length - 32).toString("base64url");
+})();
+
+let internalKey: crypto.KeyObject | null = null;
+try { internalKey = crypto.createPrivateKey(fs.readFileSync(INTERNAL_AUTH_KEY_FILE)); }
+catch { console.warn("agent: приватный ключ внутренней авторизации не найден: " + INTERNAL_AUTH_KEY_FILE); }
+
+// Тот же короткоживущий токен, что awg-ui шлёт своему awg-ctrl.
+function mintInternalToken(): string {
+    if (!internalKey) throw new Error("no internal key");
+    const t = Math.floor(Date.now() / 1000);
+    const h = Buffer.from('{"alg":"EdDSA","typ":"JWT"}').toString("base64url");
+    const p = Buffer.from(JSON.stringify({ iss: "awg-agent", iat: t, exp: t + 60 })).toString("base64url");
+    return `${h}.${p}.${crypto.sign(null, Buffer.from(`${h}.${p}`), internalKey).toString("base64url")}`;
+}
+
+// Дублируется в awg-ui/nodes.ts.
+const authMsg = (nonce: string) => Buffer.from(`awg-node-v1\n${nonce}\n${NODE_ID}`);
+
+// ── Запросы core → awg-ctrl ────────────────────────────────────────────────
+const METHODS = new Set(["GET", "POST", "PUT", "DELETE"]);
+// Агент — не открытый прокси: только API самого awg-ctrl.
+function pathAllowed(p: unknown): p is string {
+    if (typeof p !== "string" || p.length > 2048 || !/^\/[\x21-\x7e]*$/.test(p)) return false;
+    try {
+        const u = new URL(p, "http://x");
+        if (u.origin !== "http://x" || u.pathname.split("/").some(s => s === ".." || s === ".")) return false;
+        return u.pathname === "/health" || u.pathname.startsWith("/api/") || u.pathname.startsWith("/awg/");
+    } catch { return false; }
+}
+
+async function execute(m: { method?: unknown; path?: unknown; body?: unknown }): Promise<{ status: number; data: unknown }> {
+    const method = typeof m.method === "string" ? m.method.toUpperCase() : "";
+    if (!METHODS.has(method) || !pathAllowed(m.path)) return { status: 400, data: { error: "Запрос не разрешён агентом" } };
+    try {
+        const r = await axios({
+            method, url: CTRL + m.path,
+            headers: { Authorization: `Bearer ${mintInternalToken()}`, "Content-Type": "application/json" },
+            data: m.body, validateStatus: () => true, timeout: 110_000,
+        });
+        return { status: r.status, data: r.data };
+    } catch {
+        return { status: 502, data: { error: "awg-ctrl недоступен" } };
+    }
+}
+
+// ── Соединение с core ──────────────────────────────────────────────────────
+function pinOf(sock: TLSSocket): string | null {
+    const raw = sock.getPeerCertificate(true)?.raw;
+    if (!raw) return null;
+    const spki = new crypto.X509Certificate(raw).publicKey.export({ type: "spki", format: "der" }) as Buffer;
+    return crypto.createHash("sha256").update(spki).digest("base64url");
+}
+
+// После первого успешного входа секрет больше не нужен — убираем его с диска.
+function forgetJoinSecret() {
+    joinSecret = "";
+    delete process.env.JOIN_SECRET;
+    if (!CLI_ENV_FILE) return;
+    try {
+        const kept = fs.readFileSync(CLI_ENV_FILE, "utf8").split("\n").filter(l => !l.startsWith("JOIN_SECRET="));
+        fs.writeFileSync(CLI_ENV_FILE, kept.join("\n"));
+    } catch { /* не критично: секрет одноразовый и с истекающим сроком */ }
+}
+
+let backoff = 1000;
+const sleep = (ms: number) => new Promise<void>(r => setTimeout(r, ms));
+
+function connectOnce(): Promise<{ authFailed: boolean }> {
+    return new Promise(resolve => {
+        // Сертификат самоподписанный — цепочку не проверяем, доверие даёт pin (см. 'upgrade').
+        const ws = new WebSocket(`wss://${CORE_HOST}:${CORE_PORT}/node/v1`, {
+            rejectUnauthorized: false, handshakeTimeout: 10_000, maxPayload: 4 * 1024 * 1024,
+        });
+        let pinned = false, ready = false, deadTimer: NodeJS.Timeout | undefined;
+        const armDead = () => { clearTimeout(deadTimer); deadTimer = setTimeout(() => ws.terminate(), 60_000); };
+
+        // До этого момента ничего не отправляем и не читаем: секрет и подпись уходят только
+        // тому, чей сертификат совпал с pin из join-строки.
+        ws.on("upgrade", res => {
+            const got = pinOf(res.socket as TLSSocket);
+            if (got === CORE_PIN) { pinned = true; return; }
+            console.error("agent: сертификат core не совпал с pin — соединение отклонено");
+            ws.terminate();
+        });
+
+        ws.on("ping", armDead);
+        ws.on("message", async raw => {
+            if (!pinned) return;
+            let m: any;
+            try { m = JSON.parse(raw.toString()); } catch { ws.terminate(); return; }
+            if (m.t === "hello" && typeof m.nonce === "string") {
+                const auth: Record<string, unknown> = {
+                    t: "auth", node_id: NODE_ID,
+                    sig: crypto.sign(null, authMsg(m.nonce), nodeKey).toString("base64url"),
+                };
+                if (joinSecret) auth.join = { secret: joinSecret, pub: nodePubRaw };
+                ws.send(JSON.stringify(auth));
+            } else if (m.t === "ready") {
+                ready = true; backoff = 1000; armDead();
+                if (joinSecret) { forgetJoinSecret(); console.log("agent: нода привязана к core"); }
+                console.log("agent: подключено к core");
+            } else if (m.t === "req" && ready && Number.isInteger(m.id)) {
+                const r = await execute(m);
+                if (ws.readyState === WebSocket.OPEN) ws.send(JSON.stringify({ t: "res", id: m.id, ...r }));
+            }
+        });
+        ws.on("error", e => { if (!pinned || !ready) console.error("agent: " + (e as Error).message); });
+        ws.on("close", code => {
+            clearTimeout(deadTimer);
+            if (code === 4003) console.error("agent: core отклонил ноду (неверный ключ, просроченная или использованная ссылка)");
+            resolve({ authFailed: code === 4003 });
+        });
+    });
+}
+
+async function main() {
+    console.log(`agent: нода #${NODE_ID} → wss://${CORE_HOST}:${CORE_PORT}`);
+    for (;;) {
+        const { authFailed } = await connectOnce();
+        const wait = authFailed ? 60_000 : backoff;
+        backoff = Math.min(backoff * 2, 60_000);
+        await sleep(wait);
+    }
+}
+
+main();
@@ -0,0 +1,19 @@
+{
+  "name": "awg-agent",
+  "version": "0.3.2",
+  "private": true,
+  "description": "Агент ноды: держит исходящее WSS-соединение к core и исполняет запросы на локальном awg-ctrl",
+  "scripts": {
+    "check": "tsc --noEmit"
+  },
+  "dependencies": {
+    "axios": "^1.7.0",
+    "ws": "^8.18.0"
+  },
+  "devDependencies": {
+    "@types/node": "^22.0.0",
+    "@types/ws": "^8.5.0",
+    "tsx": "^4.0.0",
+    "typescript": "^5.0.0"
+  }
+}
@@ -0,0 +1,12 @@
+{
+  "compilerOptions": {
+    "target": "es2020",
+    "module": "commonjs",
+    "esModuleInterop": true,
+    "forceConsistentCasingInFileNames": true,
+    "strict": true,
+    "skipLibCheck": true,
+    "noEmit": true
+  },
+  "include": ["index.ts"]
+}
@@ -87,6 +87,20 @@ db.exec(`
    )
 `);

+// Пиры устройств sen://-подписки. Отдельная таблица, users не трогаем: у этих
+// пиров нет ни vpn_key, ни имени — приватный ключ живёт только на устройстве,
+// сюда приходит лишь публичный. owner — непрозрачная метка от awg-ui
+// («m<masterId>/d<deviceId>»), нужна только для комментария в conf и логов.
+db.exec(`
+    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
+    )
+`);
+
 const cfgStmts = {
    get: db.prepare<[string], { value: string }>("SELECT value FROM config WHERE key = ?"),
    set: db.prepare<[string, string]>("INSERT OR REPLACE INTO config (key, value) VALUES (?, ?)"),
@@ -276,12 +290,27 @@ interface UserRow {
    vpn_key_prev: string;
 }

+interface PeerRow {
+    pub_key:    string;
+    ip:         string;
+    psk_key:    string;
+    owner:      string;
+    created_at: number;
+}
+
 const stmts = {
+    peersAll:    db.prepare<[], PeerRow>("SELECT * FROM peers ORDER BY created_at, rowid"),
+    peerGet:     db.prepare<[string], PeerRow>("SELECT * FROM peers WHERE pub_key = ?"),
+    peerInsert:  db.prepare<[string, string, string, string, number]>("INSERT INTO peers (pub_key, ip, psk_key, owner, created_at) VALUES (?, ?, ?, ?, ?)"),
+    peerDelete:  db.prepare<[string]>("DELETE FROM peers WHERE pub_key = ?"),
+    peerRekey:   db.prepare<[string, string]>("UPDATE peers SET pub_key = ? WHERE pub_key = ?"),
+    peerPsk:     db.prepare<[string, string]>("UPDATE peers SET psk_key = ? WHERE pub_key = ?"),
+    userPubTaken: db.prepare<[string], { n: number }>("SELECT COUNT(*) AS n FROM users WHERE pub_key = ?"),
    get:    db.prepare<[string], UserRow>("SELECT * FROM users WHERE name = ?"),
    all:    db.prepare<[], UserRow>("SELECT * FROM users"),
    insert: db.prepare<[string, string, string, string, string, string]>("INSERT INTO users (name, ip, pub_key, vpn_key, psk_key, key_gen) VALUES (?, ?, ?, ?, ?, ?)"),
    delete: db.prepare<[string]>("DELETE FROM users WHERE name = ?"),
-    ips:    db.prepare<[], { ip: string }>("SELECT ip FROM users"),
+    ips:    db.prepare<[], { ip: string }>("SELECT ip FROM users UNION SELECT ip FROM peers"),
    // Перевыпуск: старый блоб уезжает в vpn_key_prev, pub_key/psk_key могут
    // смениться, если исходный ключ не удалось разобрать.
    reissue: db.prepare<[string, string, string, string, string]>(
@@ -547,17 +576,22 @@ function getPeersData(): Record<string, { online: boolean; lastHandshake: number

 function rebuildConf() {
    const users    = db.prepare("SELECT name, ip, pub_key, psk_key FROM users").all() as UserRow[];
+    const devices  = stmts.peersAll.all();
    const confFile = path.join(CONFIG.confDir, `${CONFIG.interface}.conf`);
    if (!existsSync(confFile)) return;

    const conf  = readFileSync(confFile, "utf8");
    const iface = conf.split(/^\[Peer\]/m)[0].trimEnd();
-    const peers = (users as any[]).map(u =>
-        `\n# ${u.name}\n[Peer]\nPublicKey = ${u.pub_key}\nPresharedKey = ${u.psk_key}\nAllowedIPs = ${u.ip}/32\nPersistentKeepalive = ${CONFIG.keepalive}`
+    // Без записей в peers вывод байт-в-байт прежний.
+    const peers = [
+        ...users.map(u => ({ label: u.name, ...u })),
+        ...devices.map(d => ({ label: d.owner || "device", ...d })),
+    ].map(u =>
+        `\n# ${u.label}\n[Peer]\nPublicKey = ${u.pub_key}\nPresharedKey = ${u.psk_key}\nAllowedIPs = ${u.ip}/32\nPersistentKeepalive = ${CONFIG.keepalive}`
    ).join("\n");

    writeFileSync(confFile, iface + "\n" + peers + "\n");
-    logger.info("conf rebuilt", { peers: users.length });
+    logger.info("conf rebuilt", { peers: users.length + devices.length });
 }

 const SERVER_PRIV_KEY_FILE = "/etc/amnezia/server_private.key";
@@ -829,6 +863,89 @@ function removeUser(username: string) {
    logger.info("user removed", { name: username });
 }

+// ── Пиры устройств (sen://) ────────────────────────────────────────────────
+// awg-ctrl про мастер-ключи ничего не знает: ему приходит «добавь пира с этим
+// публичным ключом». Приватного ключа устройства здесь нет и быть не может.
+class HttpError extends Error {
+    constructor(public status: number, message: string) { super(message); }
+}
+
+// Публичный ключ WireGuard: base64 от 32 байт (44 символа, последний «=»).
+function checkPubKey(k: unknown): string {
+    if (typeof k !== "string" || !/^[A-Za-z0-9+/]{43}=$/.test(k) || Buffer.from(k, "base64").length !== 32)
+        throw new HttpError(400, "Неверный публичный ключ");
+    return k;
+}
+
+// В пути base64url: «/» и «+» обычного base64 в URL ломают маршрут.
+function pubKeyFromParam(p: string): string {
+    return checkPubKey(Buffer.from(p, "base64url").toString("base64"));
+}
+
+function assertPubKeyFree(pub: string) {
+    if (stmts.peerGet.get(pub) || stmts.userPubTaken.get(pub)!.n > 0 || pub === getServerPublicKey())
+        throw new HttpError(409, "Публичный ключ уже используется");
+}
+
+function addPeer(pubKey: string, owner: string): { ip: string; psk_key: string } {
+    checkPubKey(pubKey);
+    const psk = run("awg genpsk");
+    const ip = db.transaction(() => {
+        assertPubKeyFree(pubKey);
+        const ip = nextIp();
+        stmts.peerInsert.run(pubKey, ip, psk, owner, Math.floor(Date.now() / 1000));
+        return ip;
+    })();
+
+    const r = setPeer(pubKey, psk, ip);
+    if (r.status !== 0) {
+        stmts.peerDelete.run(pubKey);
+        throw new Error(`awg set failed: ${r.stderr?.toString()}`);
+    }
+    rebuildConf();
+    logger.info("peer added", { owner, ip });
+    return { ip, psk_key: psk };
+}
+
+// Смена ключа устройства: IP и PSK остаются, меняется только pub_key.
+function replacePeer(oldPub: string, newPub: string): { ip: string; psk_key: string } {
+    checkPubKey(newPub);
+    const old = stmts.peerGet.get(oldPub);
+    if (!old) throw new HttpError(404, "Пир не найден");
+    db.transaction(() => { assertPubKeyFree(newPub); stmts.peerRekey.run(newPub, oldPub); })();
+
+    const r = setPeer(newPub, old.psk_key, old.ip);
+    if (r.status !== 0) {
+        stmts.peerRekey.run(oldPub, newPub);
+        throw new Error(`awg set failed: ${r.stderr?.toString()}`);
+    }
+    spawnSync("awg", ["set", CONFIG.interface, "peer", oldPub, "remove"]);
+    rebuildConf();
+    logger.info("peer rekeyed", { owner: old.owner, ip: old.ip });
+    return { ip: old.ip, psk_key: old.psk_key };
+}
+
+function rotatePeerPsk(pub: string): { ip: string; psk_key: string } {
+    const peer = stmts.peerGet.get(pub);
+    if (!peer) throw new HttpError(404, "Пир не найден");
+    const psk = run("awg genpsk");
+    const r = setPeer(pub, psk, peer.ip);
+    if (r.status !== 0) throw new Error(`awg set failed: ${r.stderr?.toString()}`);
+    stmts.peerPsk.run(psk, pub);
+    rebuildConf();
+    logger.info("peer psk rotated", { owner: peer.owner });
+    return { ip: peer.ip, psk_key: psk };
+}
+
+function removePeer(pub: string) {
+    const peer = stmts.peerGet.get(pub);
+    if (!peer) throw new HttpError(404, "Пир не найден");
+    stmts.peerDelete.run(pub);
+    spawnSync("awg", ["set", CONFIG.interface, "peer", pub, "remove"]);
+    rebuildConf();
+    logger.info("peer removed", { owner: peer.owner });
+}
+
 const app = express();
 app.use(express.json({ limit: "1kb" }));

@@ -863,7 +980,10 @@ function validateName(req: Request, res: Response, next: NextFunction) {
 function handler(fn: (req: Request, res: Response) => void | Promise<void>) {
    return async (req: Request, res: Response) => {
        try { await fn(req, res); }
-        catch (e) { logger.error("handler error", { error: e }); res.status(500).json({ error: "Internal server error" }); }
+        catch (e) {
+            if (e instanceof HttpError) { res.status(e.status).json({ error: e.message }); return; }
+            logger.error("handler error", { error: e }); res.status(500).json({ error: "Internal server error" });
+        }
    };
 }

@@ -931,6 +1051,56 @@ app.delete("/api/users/:name", auth, validateName, handler((req, res) => {
    res.json({ success: true, name: req.params.name });
 }));

+app.post("/api/peers", auth, handler((req, res) => {
+    const { pub_key, owner } = (req.body ?? {}) as { pub_key?: string; owner?: string };
+    if (typeof owner !== "string" || !/^[\w/.-]{0,64}$/.test(owner)) throw new HttpError(400, "Неверный owner");
+    res.status(201).json(addPeer(checkPubKey(pub_key), owner));
+}));
+
+app.get("/api/peers", auth, handler((_req, res) => {
+    const stats = getPeersData();
+    res.json({
+        peers: stmts.peersAll.all().map(p => ({
+            pub_key: p.pub_key, ip: p.ip, psk_key: p.psk_key, owner: p.owner,
+            online:        stats[p.pub_key]?.online        ?? false,
+            lastHandshake: stats[p.pub_key]?.lastHandshake ?? 0,
+            rx:            stats[p.pub_key]?.rx            ?? 0,
+            tx:            stats[p.pub_key]?.tx            ?? 0,
+        })),
+    });
+}));
+
+app.put("/api/peers/:pub", auth, handler((req, res) => {
+    const { pub_key } = (req.body ?? {}) as { pub_key?: string };
+    res.json(replacePeer(pubKeyFromParam(req.params.pub), checkPubKey(pub_key)));
+}));
+
+app.post("/api/peers/:pub/psk", auth, handler((req, res) => {
+    res.json(rotatePeerPsk(pubKeyFromParam(req.params.pub)));
+}));
+
+app.delete("/api/peers/:pub", auth, handler((req, res) => {
+    removePeer(pubKeyFromParam(req.params.pub));
+    res.json({ success: true });
+}));
+
+// Общая часть клиентского конфига для подписки. Ключи obfuscation — именами .conf;
+// пустые (I2–I5, весь 3.x-блок на 2.0) не выводятся, как и в самом conf.
+app.get("/api/profile", auth, handler((_req, res) => {
+    const awg: Record<string, string> = {};
+    for (const [k, v] of Object.entries(CONFIG.awgParams)) if (String(v) !== "") awg[k] = String(v);
+    res.json({
+        name:      CONFIG.serverName,
+        endpoint:  `${CONFIG.serverIp}:${CONFIG.serverPort}`,
+        server_pub: getServerPublicKey(),
+        gen:       CONFIG.gen,
+        dns:       [CONFIG.dns1, CONFIG.dns2],
+        keepalive: CONFIG.keepalive,
+        mtu:       CONFIG.mtu,
+        awg,
+    });
+}));
+
 app.post("/awg/restart", auth, handler((_req, res) => {
    restartAwg();
    res.json({ success: true });
@@ -1,6 +1,6 @@
 {
  "name": "awg-control",
-  "version": "0.2.0",
+  "version": "0.3.2",
  "description": "",
  "main": "dist/index.js",
  "scripts": {
@@ -0,0 +1,130 @@
+// 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-ui + awg-ctrl целиком в
+// памяти, AWG не нужен. Логин admin / admin. Запуск: npm run dev:mock.
+import express from "express";
+import crypto from "crypto";
+import { encodeSenLink } from "./sen";
+
+const app = express();
+app.use(express.json());
+
+const now = () => Math.floor(Date.now() / 1000);
+const rnd = (n: number) => Math.floor(Math.random() * n);
+const b64 = (n: number) => crypto.randomBytes(n).toString("base64");
+const GEN = "3.1";
+
+// ── пользователи (vpn://) ──
+interface U { name: string; ip: string; pub_key: string; vpn_key: string; key_gen: string; online: boolean; lastHandshake: number; rx: number; tx: number }
+const users: U[] = ["alice", "bob", "laptop-ivan"].map((name, i) => ({
+    name, ip: `10.9.0.${i + 2}`, pub_key: b64(32), vpn_key: "vpn://" + crypto.randomBytes(48).toString("base64url"),
+    key_gen: GEN, online: i !== 1, lastHandshake: now() - rnd(600), rx: rnd(5e8), tx: rnd(2e8),
+}));
+
+// ── серверы: core (id 0), нода в сети и нода, ещё не подключавшаяся ──
+// Пользователи хранятся по серверам; X-Server-Id выбирает набор, как в настоящей панели.
+const usersOf: Record<number, U[]> = {
+    0: users,
+    1: ["dave", "erin"].map((name, i) => ({
+        name, ip: `10.9.0.${i + 2}`, pub_key: b64(32), vpn_key: "vpn://" + crypto.randomBytes(48).toString("base64url"),
+        key_gen: "2", online: i === 0, lastHandshake: now() - rnd(600), rx: rnd(5e8), tx: rnd(2e8),
+    })),
+};
+const srv = (q: express.Request) => { const n = Number(q.headers["x-server-id"]); return Number.isInteger(n) && usersOf[n] ? n : 0; };
+const U_ = (q: express.Request) => usersOf[srv(q)];
+interface MNode { id: number; name: string; ip: string; gen: string; online: boolean; pending: boolean }
+const mnodes: MNode[] = [
+    { id: 1, name: "Frankfurt", ip: "198.51.100.4", gen: "2", online: true, pending: false },
+    { id: 2, name: "Tokyo", ip: "", gen: "2", online: false, pending: true },
+];
+let nodeId = 2;
+const joinStr = (id: number) => "awgjoin://" + Buffer.from(JSON.stringify({ v: 1, h: "localhost", p: 8443, pin: crypto.randomBytes(32).toString("base64url"), n: id, s: crypto.randomBytes(16).toString("base64url") })).toString("base64url");
+
+// ── API-ключи ──
+const apiKeys = [{ id: 1, label: "ci-bot", prefix: "awgk_Xk2mQ9aB…", server_id: 0, created_at: now() - 86400 * 5, last_used: now() - 3600 as number | null }];
+let apiId = 1;
+
+// ── мастер-ключи sen:// ──
+interface Dev { 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 }
+interface MK { id: number; label: string; device_limit: number; created_at: number; secret: Buffer; devs: Dev[]; servers: number[] }
+let mkId = 1, devId = 1;
+const dev = (name: string, platform: string, online: boolean, version = "0.6.5"): Dev => ({ id: devId++, device_id: crypto.randomUUID(), device_name: name, platform, version, created_at: now() - 86400, last_seen: now() - rnd(900), rekey_requested: false, online, lastHandshake: now() - rnd(300), rx: rnd(9e8), tx: rnd(3e8) });
+const masters: MK[] = [{ id: mkId++, label: "Семья", device_limit: 3, created_at: now() - 86400 * 2, secret: crypto.randomBytes(16), devs: [dev("MacBook Ивана", "macOS", true), dev("Windows-ПК", "Windows", false, "0.6.2")], servers: [0, 1] }];
+const signPub = crypto.randomBytes(32);
+const mkOut = (m: MK) => ({ id: m.id, label: m.label, device_limit: m.device_limit, devices: m.devs.length, servers: m.servers, created_at: m.created_at });
+// Мок: устройство «догнано» на всех серверах ключа, кроме 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 find = (id: string) => masters.find(m => m.id === Number(id));
+
+app.get("/ui/brand", (_q, r) => r.json({ brand: "Forgetting", channel: "Beta", version: "0.2.2-mock" }));
+app.post("/login", (q, r) => q.body.user === "admin" && q.body.pass === "admin" ? r.json({ token: "mock." + crypto.randomBytes(8).toString("hex") + ".sig" }) : r.status(401).json({ error: "Неверный логин или пароль" }));
+app.post("/logout", (_q, r) => r.json({ ok: true }));
+app.get("/health", (q, r) => {
+    const id = srv(q), n = mnodes.find(x => x.id === id);
+    r.json({ status: "ok", server: n?.name ?? "VPN (mock)", ip: n?.ip ?? "203.0.113.7", gen: n?.gen ?? GEN, awg: { status: "ok", peers: usersOf[id].length, module: "3.0.1", tools: "1.0.0" } });
+});
+
+// ── серверы ──
+const nodeView = () => [
+    { id: 0, name: "VPN (mock)", local: true, online: true, pending: false, last_seen: null, health: { server: "VPN (mock)", ip: "203.0.113.7", gen: GEN, peers: users.length, awg_up: true, module: "3.0.1", tools: "1.0.0" } },
+    ...mnodes.map(n => ({ id: n.id, name: n.name, local: false, online: n.online, pending: n.pending, last_seen: n.online ? now() - 5 : null,
+        health: n.online ? { server: n.name, ip: n.ip, gen: n.gen, peers: (usersOf[n.id] ?? []).length, awg_up: true, module: "3.0.1", tools: "1.0.0" } : null })),
+];
+app.get("/ui/nodes", (_q, r) => r.json({ hub: true, local: true, nodes: nodeView() }));
+app.post("/ui/nodes", (q, r) => {
+    const name = String(q.body.name ?? "");
+    if (!name || name.length > 40) return r.status(400).json({ error: "Имя: до 40 символов, без переводов строк и <>" });
+    const id = ++nodeId; mnodes.push({ id, name, ip: "", gen: "2", online: false, pending: true });
+    r.status(201).json({ id, name, join: joinStr(id), expires_in: 3600 });
+});
+app.post("/ui/nodes/:id/join", (q, r) => { const n = mnodes.find(x => x.id === Number(q.params.id)); n ? r.json({ id: n.id, name: n.name, join: joinStr(n.id), expires_in: 3600 }) : r.status(404).json({ error: "Не найден" }); });
+app.delete("/ui/nodes/:id", (q, r) => { const i = mnodes.findIndex(x => x.id === Number(q.params.id)); if (i < 0) return r.status(404).json({ error: "Не найден" }); mnodes.splice(i, 1); r.json({ success: true }); });
+app.post("/awg/restart", (_q, r) => r.json({ up: true }));
+app.get("/awg/status", (_q, r) => r.json({ up: true, peers: users.length }));
+
+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) }));
+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);
+    const name = String(q.body.name ?? "");
+    if (!/^[a-zA-Z0-9_-]{1,32}$/.test(name)) return r.status(400).json({ error: "Имя: буквы, цифры, _ и -, до 32 символов" });
+    if (users.some(u => u.name === name)) return r.status(409).json({ error: "Пользователь уже существует" });
+    const u: U = { name, ip: `10.9.0.${users.length + 2}`, pub_key: b64(32), vpn_key: "vpn://" + crypto.randomBytes(48).toString("base64url"), key_gen: GEN, online: false, lastHandshake: 0, rx: 0, tx: 0 };
+    users.push(u); r.status(201).json(u);
+});
+app.post("/api/users/:name", (q, r) => { const u = U_(q).find(x => x.name === q.params.name); u ? r.json(u) : r.status(404).json({ error: "Пользователь не найден" }); });
+app.delete("/api/users/:name", (q, r) => { const users = U_(q); const i = users.findIndex(x => x.name === q.params.name); if (i >= 0) users.splice(i, 1); r.json({ success: true }); });
+
+app.get("/ui/apikeys", (_q, r) => r.json({ keys: apiKeys }));
+app.post("/ui/apikeys", (q, r) => { const k = { id: ++apiId, label: q.body.label, prefix: "awgk_" + crypto.randomBytes(4).toString("hex") + "…", server_id: 0, created_at: now(), last_used: null }; apiKeys.push(k); r.status(201).json({ ...k, key: "awgk_" + crypto.randomBytes(24).toString("base64url") }); });
+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 }); });
+
+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;
+    if (!q.body.label || !Number.isInteger(limit) || limit < 1 || limit > 100) return r.status(400).json({ error: "Неверные параметры" });
+    const m: MK = { id: mkId++, label: q.body.label, device_limit: limit, created_at: now(), secret: crypto.randomBytes(16), devs: [], servers: q.body.servers ?? [0] };
+    masters.push(m); r.status(201).json(mkOut(m));
+});
+app.patch("/ui/masterkeys/:id", (q, r) => {
+    const m = find(q.params.id); if (!m) return r.status(404).json({ error: "Не найден" });
+    if (q.body.servers !== undefined) { if (!Array.isArray(q.body.servers) || !q.body.servers.length) return r.status(400).json({ error: "Нужен хотя бы один сервер" }); m.servers = [...q.body.servers].sort(); }
+    if (q.body.label) m.label = q.body.label; if (q.body.device_limit) m.device_limit = q.body.device_limit; r.json(mkOut(m));
+});
+app.post("/ui/masterkeys/:id/rotate", (q, r) => { const m = find(q.params.id); if (!m) return r.status(404).json({ error: "Не найден" }); m.secret = crypto.randomBytes(16); r.json({ id: m.id }); });
+app.post("/ui/masterkeys/:id/rekey", (q, r) => { const m = find(q.params.id); if (!m) return r.status(404).json({ error: "Не найден" }); m.devs.forEach(d => d.rekey_requested = true); r.json({ id: m.id }); });
+app.delete("/ui/masterkeys/:id", (q, r) => { const i = masters.findIndex(m => m.id === Number(q.params.id)); if (i >= 0) masters.splice(i, 1); r.json({ success: true }); });
+app.get("/ui/masterkeys/:id/link", (q, r) => {
+    const m = find(q.params.id); if (!m) return r.status(404).json({ error: "Не найден" });
+    r.json({ link: encodeSenLink({ tls: false, addrs: [{ host: "203.0.113.7", port: 41234 }], secret: m.secret, signPub, name: m.label }), tls: false });
+});
+app.get("/ui/masterkeys/:id/devices", (q, r) => { const m = find(q.params.id); m ? r.json({ devices: m.devs.map(d => devOut(m, d)) }) : r.status(404).json({ error: "Не найден" }); });
+app.delete("/ui/devices/:id", (q, r) => { for (const m of masters) m.devs = m.devs.filter(d => d.id !== Number(q.params.id)); r.json({ success: true }); });
+app.post("/ui/devices/:id/rekey", (q, r) => { masters.forEach(m => m.devs.forEach(d => { if (d.id === Number(q.params.id)) d.rekey_requested = true; })); r.json({}); });
+app.post("/ui/devices/:id/psk", (_q, r) => r.json({ pending: 0 }));
+
+const MOCK_PORT = Number(process.env.MOCK_PORT) || 8080;
+app.listen(MOCK_PORT, () => console.log(`mock: http://localhost:${MOCK_PORT} (login admin / admin)`));
@@ -0,0 +1,363 @@
+// 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.
+//
+// Несколько серверов под одной панелью: core (эта awg-ui) и nodes — VPN-серверы,
+// которые сами открывают к core исходящее WSS-соединение (awg-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 crypto from "crypto";
+import fs from "fs";
+import https from "https";
+import path from "path";
+import { spawnSync } from "child_process";
+import { Router, type Request, type Response } from "express";
+import type Database from "better-sqlite3";
+import { WebSocketServer, WebSocket } from "ws";
+import { spkiPin, publicKeyFromRaw } from "./sen";
+
+export type Ctrl = (method: string, urlPath: string, body?: unknown) => Promise<{ status: number; data: any }>;
+
+interface NodeRow {
+    id: number; name: string; pub: string | null;
+    join_hash: Buffer | null; join_expires: number | null;
+    created_at: number; last_seen: number | null;
+}
+
+interface Health {
+    server: string; ip: string; gen: string; peers: number;
+    awg_up: boolean; module: string; tools: string;
+}
+
+interface Conn {
+    ws: WebSocket; seq: number; alive: boolean;
+    pending: Map<number, { resolve: (r: { status: number; data: any }) => void; timer: NodeJS.Timeout }>;
+}
+
+const JOIN_TTL      = 3600;          // секунд жизни одноразового секрета
+const AUTH_TIMEOUT  = 10_000;        // на challenge–response после открытия сокета
+const HEALTH_EVERY  = 15_000;
+const PING_EVERY    = 20_000;
+const RPC_TIMEOUT   = 15_000;
+const RPC_SLOW      = 120_000;       // /awg/*: рестарт и upgrade идут долго
+const NAME_RE       = /^[^\r\n<>]{1,40}$/;
+const HOST_RE       = /^[A-Za-z0-9.:_-]{1,253}$/;
+
+// Сообщение, которое нода подписывает своим ключом. Дублируется в awg-agent.
+const authMsg = (nonce: string, nodeId: number) => Buffer.from(`awg-node-v1\n${nonce}\n${nodeId}`);
+
+export function createNodes(deps: { uidb: Database.Database; ctrlLocal: Ctrl; baseDir: string }) {
+    const { uidb, ctrlLocal } = deps;
+
+    const NODE_PORT = Number(process.env.NODE_PORT) || 0;
+    const LOCAL     = (process.env.LOCAL_NODE ?? "on").toLowerCase() !== "off";
+    const file = (env: string | undefined, name: string) => env || path.join(deps.baseDir, name);
+
+    // ── TLS: самоподписанный сертификат, pin которого зашит в join-строки ────
+    // Живёт столько же, сколько core: пересоздать = переподключить все ноды.
+    let tls: { key: Buffer; cert: Buffer } | null = null;
+    let pin: Buffer | null = null;
+    if (NODE_PORT) {
+        const keyF = file(process.env.NODE_TLS_KEY_FILE,  "node_tls.key");
+        const crtF = file(process.env.NODE_TLS_CERT_FILE, "node_tls.crt");
+        try {
+            if (!fs.existsSync(keyF) && !fs.existsSync(crtF)) {
+                const r = spawnSync("openssl", [
+                    "req", "-x509", "-newkey", "ec", "-pkeyopt", "ec_paramgen_curve:prime256v1", "-nodes",
+                    "-keyout", keyF, "-out", crtF, "-days", "3650", "-subj", "/CN=awg-node",
+                ], { stdio: "ignore" });
+                if (r.status !== 0) throw new Error("openssl");
+                fs.chmodSync(keyF, 0o600); fs.chmodSync(crtF, 0o600);
+                console.log("nodes: создан самоподписанный сертификат " + crtF);
+            }
+            tls = { key: fs.readFileSync(keyF), cert: fs.readFileSync(crtF) };
+            pin = spkiPin(tls.cert.toString());
+        } catch {
+            console.warn("nodes: сертификат хаба недоступен (" + crtF + ") — приём нод отключён");
+            tls = null;
+        }
+    }
+
+    // ── Схема ──────────────────────────────────────────────────────────────
+    uidb.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
+        );
+    `);
+    const q = {
+        all:    uidb.prepare("SELECT * FROM nodes ORDER BY id"),
+        byId:   uidb.prepare<[number]>("SELECT * FROM nodes WHERE id = ?"),
+        insert: uidb.prepare<[string, Buffer, number, number]>("INSERT INTO nodes (name, join_hash, join_expires, created_at) VALUES (?, ?, ?, ?)"),
+        rename: uidb.prepare<[string, number]>("UPDATE nodes SET name = ? WHERE id = ?"),
+        rejoin: uidb.prepare<[Buffer, number, number]>("UPDATE nodes SET join_hash = ?, join_expires = ? WHERE id = ? AND pub IS NULL"),
+        bind:   uidb.prepare<[string, number]>("UPDATE nodes SET pub = ?, join_hash = NULL, join_expires = NULL WHERE id = ?"),
+        seen:   uidb.prepare<[number, number]>("UPDATE nodes SET last_seen = ? WHERE id = ?"),
+        delete: uidb.prepare<[number]>("DELETE FROM nodes WHERE id = ?"),
+    };
+    const now = () => Math.floor(Date.now() / 1000);
+    const sha = (b: Buffer) => crypto.createHash("sha256").update(b).digest();
+
+    // ── RPC к нодам ────────────────────────────────────────────────────────
+    const conns  = new Map<number, Conn>();
+    const health = new Map<number, Health>();
+    const OFFLINE = { status: 502, data: { error: "Сервер недоступен" } };
+
+    function rpc(id: number, method: string, urlPath: string, body?: unknown): Promise<{ status: number; data: any }> {
+        const c = conns.get(id);
+        if (!c || c.ws.readyState !== WebSocket.OPEN) return Promise.resolve(OFFLINE);
+        return new Promise(resolve => {
+            const rid = ++c.seq;
+            const timer = setTimeout(() => {
+                c.pending.delete(rid);
+                resolve({ status: 504, data: { error: "Сервер не ответил" } });
+            }, urlPath.startsWith("/awg/") ? RPC_SLOW : RPC_TIMEOUT);
+            c.pending.set(rid, { resolve, timer });
+            c.ws.send(JSON.stringify({ t: "req", id: rid, method, path: urlPath, body }));
+        });
+    }
+
+    /** Контроллер нужного сервера. 0 — локальный awg-ctrl, остальное — нода по WSS. */
+    function ctrlFor(serverId: number): Ctrl {
+        if (serverId === 0) {
+            if (!LOCAL) return async () => ({ status: 404, data: { error: "Локальный сервер не настроен" } });
+            return ctrlLocal;
+        }
+        if (!q.byId.get(serverId)) return async () => ({ status: 404, data: { error: "Сервер не найден" } });
+        return (m, p, b) => rpc(serverId, m, p, b);
+    }
+
+    const exists = (id: number) => (id === 0 ? LOCAL : q.byId.get(id) !== undefined);
+
+    /** Есть ли сейчас связь с сервером (локальный считаем доступным всегда — до первого отказа awg-ctrl). */
+    const isOnline = (id: number) => (id === 0 ? LOCAL : conns.has(id));
+
+    /** Все серверы реестра: локальный (если есть) и ноды. */
+    const ids = (): number[] => [...(LOCAL ? [0] : []), ...(q.all.all() as NodeRow[]).map(n => n.id)];
+
+    // Подписчики на «сервер снова на связи» — подписка по этому сигналу догоняет пропущенное.
+    const onlineHandlers: ((id: number) => void)[] = [];
+    const onOnline = (cb: (id: number) => void) => { onlineHandlers.push(cb); };
+
+    /** Сервер по умолчанию: локальный, а без него — первая нода. */
+    function defaultId(): number {
+        if (LOCAL) return 0;
+        return (q.all.all() as NodeRow[])[0]?.id ?? 0;
+    }
+
+    async function refreshHealth(id: number) {
+        const r = await (id === 0 ? ctrlLocal("GET", "/health") : rpc(id, "GET", "/health")).catch(() => null);
+        const d = r?.data;
+        if (d && typeof d === "object" && typeof d.server === "string") {
+            health.set(id, {
+                server: d.server, ip: d.ip ?? "", gen: d.gen ?? "2", peers: d.awg?.peers ?? 0,
+                awg_up: d.awg?.status === "ok", module: d.awg?.module ?? "", tools: d.awg?.tools ?? "",
+            });
+        } else health.delete(id);
+    }
+
+    // ── Хаб: приём соединений от нод ───────────────────────────────────────
+    const failHits = new Map<string, { n: number; reset: number }>();
+    const failed = (ip: string) => {
+        const t = Date.now(), e = failHits.get(ip);
+        if (!e || e.reset < t) failHits.set(ip, { n: 1, reset: t + 15 * 60_000 });
+        else e.n++;
+    };
+    const blocked = (ip: string) => {
+        const e = failHits.get(ip);
+        return !!e && e.reset > Date.now() && e.n >= 20;
+    };
+
+    function dropConn(id: number, c: Conn) {
+        for (const p of c.pending.values()) { clearTimeout(p.timer); p.resolve(OFFLINE); }
+        c.pending.clear();
+        if (conns.get(id) === c) { conns.delete(id); health.delete(id); }
+    }
+
+    function onConnection(ws: WebSocket, req: { socket: { remoteAddress?: string } }) {
+        const ip = req.socket.remoteAddress ?? "unknown";
+        if (blocked(ip)) { ws.close(4029, "rate_limited"); return; }
+
+        const nonce = crypto.randomBytes(16).toString("base64url");
+        let conn: Conn | null = null;
+        let nodeId = 0;
+        const authTimer = setTimeout(() => ws.close(4001, "auth_timeout"), AUTH_TIMEOUT);
+        const deny = () => { failed(ip); ws.close(4003, "unauthorized"); };
+
+        function authenticate(m: any) {
+            if (m?.t !== "auth" || !Number.isInteger(m.node_id) || typeof m.sig !== "string") return deny();
+            const row = q.byId.get(m.node_id) as NodeRow | undefined;
+            if (!row) return deny();
+
+            let pubB64: string | null = row.pub;
+            const joining = pubB64 === null;
+            if (joining) {
+                const j = m.join;
+                if (!row.join_hash || !row.join_expires || row.join_expires < now()
+                    || typeof j?.secret !== "string" || typeof j?.pub !== "string") return deny();
+                const h = sha(Buffer.from(j.secret, "base64url"));
+                if (h.length !== row.join_hash.length || !crypto.timingSafeEqual(h, row.join_hash)) return deny();
+                pubB64 = j.pub;
+            }
+            try {
+                const key = publicKeyFromRaw(Buffer.from(pubB64 as string, "base64url"));
+                if (!crypto.verify(null, authMsg(nonce, row.id), key, Buffer.from(m.sig, "base64url"))) return deny();
+            } catch { return deny(); }
+
+            clearTimeout(authTimer);
+            if (joining) q.bind.run(pubB64 as string, row.id);
+            q.seen.run(now(), row.id);
+
+            const old = conns.get(row.id);
+            conn = { ws, seq: 0, alive: true, pending: new Map() };
+            conns.set(row.id, conn);
+            nodeId = row.id;
+            if (old) { dropConn(row.id, old); conns.set(row.id, conn); old.ws.close(4000, "replaced"); }
+
+            ws.send(JSON.stringify({ t: "ready" }));
+            console.log(`nodes: «${row.name}» (#${row.id}) подключена${joining ? " (первое подключение)" : ""}`);
+            void refreshHealth(row.id);
+            for (const cb of onlineHandlers) { try { cb(row.id); } catch { /* подписчик сам разберётся */ } }
+        }
+
+        ws.on("message", raw => {
+            let m: any;
+            try { m = JSON.parse(raw.toString()); } catch { ws.close(4002, "bad_frame"); return; }
+            if (!conn) { authenticate(m); return; }
+            if (m?.t === "res" && Number.isInteger(m.id)) {
+                const p = conn.pending.get(m.id);
+                if (!p) return;
+                conn.pending.delete(m.id);
+                clearTimeout(p.timer);
+                p.resolve({ status: Number(m.status) || 502, data: m.data });
+            }
+        });
+        ws.on("pong", () => { if (conn) conn.alive = true; });
+        ws.on("close", () => {
+            clearTimeout(authTimer);
+            if (conn) { dropConn(nodeId, conn); console.log(`nodes: #${nodeId} отключена`); }
+        });
+        ws.on("error", () => { /* close придёт следом */ });
+
+        ws.send(JSON.stringify({ t: "hello", nonce }));
+    }
+
+    function start() {
+        if (LOCAL) {
+            void refreshHealth(0);
+            for (const cb of onlineHandlers) { try { cb(0); } catch { /* подписчик сам разберётся */ } }
+        }
+        if (!NODE_PORT || !tls) return;
+        const server = https.createServer(tls);
+        const wss = new WebSocketServer({ server, path: "/node/v1", maxPayload: 4 * 1024 * 1024 });
+        wss.on("connection", onConnection);
+        server.listen(NODE_PORT, () => console.log(`nodes: hub on :${NODE_PORT} (wss)`));
+
+        setInterval(() => {
+            for (const [id, c] of conns) {
+                if (!c.alive) { c.ws.terminate(); dropConn(id, c); continue; }
+                c.alive = false;
+                try { c.ws.ping(); } catch { /* закроется само */ }
+            }
+        }, PING_EVERY).unref();
+        setInterval(() => { for (const id of conns.keys()) void refreshHealth(id); }, HEALTH_EVERY).unref();
+    }
+
+    // ── Роуты панели (монтируются в server.ts за JWT) ──────────────────────
+    const joinString = (host: string, id: number, secret: Buffer) => "awgjoin://" + Buffer.from(JSON.stringify({
+        v: 1, h: host, p: NODE_PORT, pin: (pin as Buffer).toString("base64url"), n: id, s: secret.toString("base64url"),
+    })).toString("base64url");
+
+    const hostOf = (req: Request): string => {
+        const given = (req.body as { host?: unknown } | undefined)?.host;
+        if (typeof given === "string" && HOST_RE.test(given)) return given;
+        return (req.headers.host ?? "").replace(/:\d+$/, "").replace(/^\[|\]$/g, "");
+    };
+    const idOf = (req: Request) => Number(req.params.id);
+    const validId = (n: number) => Number.isInteger(n) && n >= 1;
+    const hubReady = () => NODE_PORT > 0 && tls !== null && pin !== null;
+
+    const router = Router();
+
+    router.get("/", async (_req: Request, res: Response) => {
+        if (LOCAL) await refreshHealth(0);
+        const nodes: unknown[] = [];
+        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, health: h });
+        }
+        for (const n of q.all.all() as NodeRow[]) {
+            nodes.push({
+                id: n.id, name: n.name, local: false, online: conns.has(n.id),
+                pending: n.pub === null, last_seen: n.last_seen, health: health.get(n.id) ?? null,
+            });
+        }
+        res.json({ hub: hubReady(), local: LOCAL, nodes });
+    });
+
+    router.post("/", (req: Request, res: Response) => {
+        if (!hubReady()) { res.status(503).json({ error: "Приём нод не настроен (NODE_PORT / сертификат)" }); return; }
+        const name = (req.body as { name?: unknown } | undefined)?.name;
+        if (typeof name !== "string" || !NAME_RE.test(name)) { res.status(400).json({ error: "Имя: до 40 символов, без переводов строк и <>" }); return; }
+        const host = hostOf(req);
+        if (!HOST_RE.test(host)) { res.status(400).json({ error: "Не удалось определить адрес core" }); return; }
+        const secret = crypto.randomBytes(16);
+        const id = Number(q.insert.run(name, sha(secret), now() + JOIN_TTL, now()).lastInsertRowid);
+        res.status(201).json({ id, name, join: joinString(host, id, secret), expires_in: JOIN_TTL });
+    });
+
+    // Новая join-строка для ноды, которая ещё не подключалась (истёк срок / потеряли).
+    router.post("/:id/join", (req: Request, res: Response) => {
+        if (!hubReady()) { res.status(503).json({ error: "Приём нод не настроен (NODE_PORT / сертификат)" }); return; }
+        const id = idOf(req);
+        const n = validId(id) ? q.byId.get(id) as NodeRow | undefined : undefined;
+        if (!n) { res.status(404).json({ error: "Не найден" }); return; }
+        if (n.pub !== null) { res.status(409).json({ error: "Нода уже подключена" }); return; }
+        const host = hostOf(req);
+        if (!HOST_RE.test(host)) { res.status(400).json({ error: "Не удалось определить адрес core" }); return; }
+        const secret = crypto.randomBytes(16);
+        q.rejoin.run(sha(secret), now() + JOIN_TTL, id);
+        res.json({ id, name: n.name, join: joinString(host, id, secret), expires_in: JOIN_TTL });
+    });
+
+    router.patch("/:id", (req: Request, res: Response) => {
+        const id = idOf(req);
+        const n = validId(id) ? q.byId.get(id) as NodeRow | undefined : undefined;
+        if (!n) { res.status(404).json({ error: "Не найден" }); return; }
+        const name = (req.body as { name?: unknown } | undefined)?.name;
+        if (typeof name !== "string" || !NAME_RE.test(name)) { res.status(400).json({ error: "Неверное имя" }); return; }
+        q.rename.run(name, id);
+        res.json({ id, name });
+    });
+
+    router.delete("/:id", (req: Request, res: Response) => {
+        const id = idOf(req);
+        const n = validId(id) ? q.byId.get(id) as NodeRow | undefined : undefined;
+        if (!n) { res.status(404).json({ error: "Не найден" }); return; }
+        // Ключи API и мастер-ключи ссылаются на server_id — не оставляем их висеть в воздухе.
+        const used = (["api_keys", "master_servers"] as const).some(t => {
+            try { return (uidb.prepare(`SELECT COUNT(*) AS n FROM ${t} WHERE server_id = ?`).get(id) as { n: number }).n > 0; }
+            catch { return false; }
+        });
+        if (used) { res.status(409).json({ error: "К серверу привязаны ключи API или мастер-ключи — сначала удалите их" }); return; }
+        const c = conns.get(id);
+        if (c) { dropConn(id, c); c.ws.close(4004, "removed"); }
+        q.delete.run(id);
+        // Хвосты подписки для этого сервера больше некому доделать.
+        for (const t of ["peer_tombstones", "server_profiles"]) {
+            try { uidb.prepare(`DELETE FROM ${t} WHERE server_id = ?`).run(id); } catch { /* таблицы ещё нет */ }
+        }
+        res.json({ success: true, id });
+    });
+
+    return { router, ctrlFor, exists, isOnline, ids, onOnline, defaultId, start };
+}
@@ -1,6 +1,6 @@
 {
  "name": "awg-ui",
-  "version": "0.2.0",
+  "version": "0.3.2",
  "private": true,
  "scripts": {
    "dev": "vite",
@@ -12,20 +12,22 @@
  },
  "dependencies": {
    "axios": "^1.7.0",
-    "jsonwebtoken": "^9.0.0",
+    "better-sqlite3": "^12.10.0",
    "qrcode": "^1.5.0",
    "react": "^18.3.0",
-    "react-dom": "^18.3.0"
+    "react-dom": "^18.3.0",
+    "ws": "^8.22.0"
  },
  "devDependencies": {
-    "concurrently": "^9.0.0",
-    "@types/jsonwebtoken": "^9.0.0",
-    "@types/qrcode": "^1.5.0",
+    "@types/better-sqlite3": "^7.6.13",
    "@types/express": "^4.17.0",
    "@types/node": "^22.0.0",
+    "@types/qrcode": "^1.5.0",
    "@types/react": "^18.3.0",
    "@types/react-dom": "^18.3.0",
+    "@types/ws": "^8.18.1",
    "@vitejs/plugin-react": "^4.3.0",
+    "concurrently": "^9.0.0",
    "express": "^4.19.0",
    "tsx": "^4.7.0",
    "typescript": "^5.4.0",
@@ -0,0 +1,234 @@
+// 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.
+//
+// sen:// — ссылка-подписка для SenAWG и подписи протокола /sub/v1.
+// Байтовая раскладка и схема подписей описаны в docs/sen-link.md; клиент
+// реализуется по ней, поэтому любое изменение здесь — изменение протокола.
+import crypto from "crypto";
+
+export const SEN_PREFIX  = "sen://";
+export const SEN_VERSION = 1;
+export const FLAG_TLS    = 0x01;
+
+const ADDR_V4     = 0x04;
+const ADDR_V6     = 0x06;
+const ADDR_DOMAIN = 0x44;
+
+export class SenLinkError extends Error {}
+
+export interface SenAddr { host: string; port: number }
+
+export interface SenLink {
+    tls: boolean;
+    addrs: SenAddr[];
+    secret: Buffer;   // 16 байт
+    signPub: Buffer;  // 32 байта, Ed25519
+    tlsPin?: Buffer;  // 32 байта, только при tls
+    name: string;
+}
+
+// ── CRC32 (IEEE) ───────────────────────────────────────────────────────────
+// zlib.crc32 появился только в Node 20.15, а целимся в 20.x целиком.
+const CRC_TABLE = (() => {
+    const t = new Uint32Array(256);
+    for (let n = 0; n < 256; n++) {
+        let c = n;
+        for (let k = 0; k < 8; k++) c = c & 1 ? 0xedb88320 ^ (c >>> 1) : c >>> 1;
+        t[n] = c >>> 0;
+    }
+    return t;
+})();
+
+export function crc32(buf: Uint8Array): number {
+    let c = 0xffffffff;
+    for (const b of buf) c = CRC_TABLE[(c ^ b) & 0xff] ^ (c >>> 8);
+    return (c ^ 0xffffffff) >>> 0;
+}
+
+// ── Адреса ─────────────────────────────────────────────────────────────────
+function ipv6ToBytes(host: string): Buffer | null {
+    const parts = host.split("::");
+    if (parts.length > 2) return null;
+    const head = parts[0] ? parts[0].split(":") : [];
+    const tail = parts.length === 2 && parts[1] ? parts[1].split(":") : [];
+    const missing = 8 - head.length - tail.length;
+    if (parts.length === 1 ? head.length !== 8 : missing < 1) return null;
+    const groups = [...head, ...Array(parts.length === 2 ? missing : 0).fill("0"), ...tail];
+    if (groups.length !== 8) return null;
+    const out = Buffer.alloc(16);
+    for (let i = 0; i < 8; i++) {
+        if (!/^[0-9a-fA-F]{1,4}$/.test(groups[i])) return null;
+        out.writeUInt16BE(parseInt(groups[i], 16), i * 2);
+    }
+    return out;
+}
+
+function bytesToIpv6(b: Buffer): string {
+    const g: string[] = [];
+    for (let i = 0; i < 16; i += 2) g.push(b.readUInt16BE(i).toString(16));
+    // Самый длинный run нулей сворачиваем в «::» — как принято в текстовой записи.
+    let bestStart = -1, bestLen = 0;
+    for (let i = 0; i < 8;) {
+        if (g[i] !== "0") { i++; continue; }
+        let j = i;
+        while (j < 8 && g[j] === "0") j++;
+        if (j - i > bestLen) { bestStart = i; bestLen = j - i; }
+        i = j;
+    }
+    if (bestLen < 2) return g.join(":");
+    return g.slice(0, bestStart).join(":") + "::" + g.slice(bestStart + bestLen).join(":");
+}
+
+function encodeAddr({ host, port }: SenAddr): Buffer {
+    if (!Number.isInteger(port) || port < 1 || port > 65535) throw new SenLinkError(`Неверный порт: ${port}`);
+    const p = Buffer.alloc(2);
+    p.writeUInt16BE(port);
+    if (/^\d{1,3}(\.\d{1,3}){3}$/.test(host)) {
+        const o = host.split(".").map(Number);
+        if (o.some(n => n > 255)) throw new SenLinkError(`Неверный IPv4: ${host}`);
+        return Buffer.concat([Buffer.from([ADDR_V4, ...o]), p]);
+    }
+    if (host.includes(":")) {
+        const b = ipv6ToBytes(host);
+        if (!b) throw new SenLinkError(`Неверный IPv6: ${host}`);
+        return Buffer.concat([Buffer.from([ADDR_V6]), b, p]);
+    }
+    const h = Buffer.from(host, "utf8");
+    if (h.length < 1 || h.length > 253 || !/^[A-Za-z0-9.-]+$/.test(host))
+        throw new SenLinkError(`Неверный домен: ${host}`);
+    return Buffer.concat([Buffer.from([ADDR_DOMAIN, h.length]), h, p]);
+}
+
+// ── Ссылка ─────────────────────────────────────────────────────────────────
+export function encodeSenLink(l: SenLink): string {
+    if (l.addrs.length < 1 || l.addrs.length > 3) throw new SenLinkError("Адресов должно быть от 1 до 3");
+    if (l.secret.length !== 16) throw new SenLinkError("secret: 16 байт");
+    if (l.signPub.length !== 32) throw new SenLinkError("signPub: 32 байта");
+    if (l.tls && l.tlsPin?.length !== 32) throw new SenLinkError("tlsPin: 32 байта при TLS");
+    const name = Buffer.from(l.name, "utf8");
+    if (name.length > 64) throw new SenLinkError("Имя: до 64 байт");
+
+    const body = Buffer.concat([
+        Buffer.from([SEN_VERSION, l.tls ? FLAG_TLS : 0, l.addrs.length]),
+        ...l.addrs.map(encodeAddr),
+        l.secret,
+        l.signPub,
+        ...(l.tls ? [l.tlsPin as Buffer] : []),
+        Buffer.from([name.length]),
+        name,
+    ]);
+    const crc = Buffer.alloc(4);
+    crc.writeUInt32BE(crc32(body));
+    return SEN_PREFIX + Buffer.concat([body, crc]).toString("base64url");
+}
+
+export function decodeSenLink(link: string): SenLink {
+    const t = link.trim();
+    if (!t.toLowerCase().startsWith(SEN_PREFIX)) throw new SenLinkError("Ссылка должна начинаться с sen://");
+    const payload = t.slice(SEN_PREFIX.length).replace(/\s+/g, "");
+    if (!/^[A-Za-z0-9_-]+$/.test(payload)) throw new SenLinkError("Ссылка повреждена: недопустимые символы");
+    const raw = Buffer.from(payload, "base64url");
+    if (raw.length < 3 + 4) throw new SenLinkError("Ссылка слишком короткая");
+
+    const body = raw.subarray(0, raw.length - 4);
+    if (raw.readUInt32BE(raw.length - 4) !== crc32(body)) throw new SenLinkError("Ссылка повреждена: не сошлась контрольная сумма");
+
+    let off = 0;
+    const need = (n: number) => { if (off + n > body.length) throw new SenLinkError("Ссылка обрезана"); };
+    const take = (n: number) => { need(n); const s = body.subarray(off, off + n); off += n; return s; };
+
+    const version = take(1)[0];
+    if (version !== SEN_VERSION) throw new SenLinkError(`Неизвестная версия ссылки: ${version}`);
+    const flags = take(1)[0];
+    if (flags & ~FLAG_TLS) throw new SenLinkError("Неизвестные флаги ссылки");
+    const n = take(1)[0];
+    if (n < 1 || n > 3) throw new SenLinkError("Неверное число адресов");
+
+    const addrs: SenAddr[] = [];
+    for (let i = 0; i < n; i++) {
+        const type = take(1)[0];
+        let host: string;
+        if (type === ADDR_V4)      host = [...take(4)].join(".");
+        else if (type === ADDR_V6) host = bytesToIpv6(Buffer.from(take(16)));
+        else if (type === ADDR_DOMAIN) {
+            const len = take(1)[0];
+            if (len < 1) throw new SenLinkError("Пустой домен");
+            host = Buffer.from(take(len)).toString("utf8");
+            if (!/^[A-Za-z0-9.-]+$/.test(host)) throw new SenLinkError("Неверный домен");
+        } else throw new SenLinkError(`Неизвестный тип адреса: ${type}`);
+        const port = Buffer.from(take(2)).readUInt16BE(0);
+        if (port === 0) throw new SenLinkError("Порт 0");
+        addrs.push({ host, port });
+    }
+
+    const secret  = Buffer.from(take(16));
+    const signPub = Buffer.from(take(32));
+    const tls     = (flags & FLAG_TLS) !== 0;
+    const tlsPin  = tls ? Buffer.from(take(32)) : undefined;
+    const nameLen = take(1)[0];
+    if (nameLen > 64) throw new SenLinkError("Имя длиннее 64 байт");
+    const name = Buffer.from(take(nameLen)).toString("utf8");
+    if (off !== body.length) throw new SenLinkError("Лишние данные в конце ссылки");
+
+    return { tls, addrs, secret, signPub, tlsPin, name };
+}
+
+// ── Ключи Ed25519 в «сыром» виде (32 байта) ────────────────────────────────
+const SPKI_ED25519_PREFIX = Buffer.from("302a300506032b6570032100", "hex");
+
+export function rawPublicKey(key: crypto.KeyObject): Buffer {
+    const der = key.export({ type: "spki", format: "der" }) as Buffer;
+    return der.subarray(der.length - 32);
+}
+
+export function publicKeyFromRaw(raw: Buffer): crypto.KeyObject {
+    if (raw.length !== 32) throw new SenLinkError("Публичный ключ Ed25519: 32 байта");
+    return crypto.createPublicKey({ key: Buffer.concat([SPKI_ED25519_PREFIX, raw]), format: "der", type: "spki" });
+}
+
+/** SHA-256 от SPKI DER сертификата — то, что кладётся в ссылку как pin. */
+export function spkiPin(certPem: string): Buffer {
+    const spki = new crypto.X509Certificate(certPem).publicKey.export({ type: "spki", format: "der" }) as Buffer;
+    return crypto.createHash("sha256").update(spki).digest();
+}
+
+// ── Подписи протокола ──────────────────────────────────────────────────────
+// Ответ: {"body": "<JSON-строка>", "sig": "<base64url>"}; sig — Ed25519 над
+// UTF-8 байтами строки body. body — именно строка, а не вложенный объект,
+// чтобы клиенту не нужна была каноническая сериализация JSON.
+export function signResponse(payload: unknown, signKey: crypto.KeyObject): { body: string; sig: string } {
+    const body = JSON.stringify(payload);
+    return { body, sig: crypto.sign(null, Buffer.from(body, "utf8"), signKey).toString("base64url") };
+}
+
+export function verifyResponse(res: { body: string; sig: string }, signPub: Buffer): boolean {
+    try {
+        return crypto.verify(null, Buffer.from(res.body, "utf8"), publicKeyFromRaw(signPub), Buffer.from(res.sig, "base64url"));
+    } catch { return false; }
+}
+
+// Запрос: подпись ключом устройства (auth_pub) над строкой
+//   METHOD \n /path \n ts \n hex(sha256(тело запроса))
+// Тело пустое → sha256 пустой строки. path — без query.
+export function requestSigString(method: string, urlPath: string, ts: number, body: Buffer | string): string {
+    const h = crypto.createHash("sha256").update(body).digest("hex");
+    return `${method.toUpperCase()}\n${urlPath}\n${ts}\n${h}`;
+}
+
+export function signRequest(
+    method: string, urlPath: string, ts: number, body: Buffer | string, authKey: crypto.KeyObject,
+): string {
+    return crypto.sign(null, Buffer.from(requestSigString(method, urlPath, ts, body), "utf8"), authKey).toString("base64url");
+}
+
+export function verifyRequest(
+    method: string, urlPath: string, ts: number, body: Buffer | string, sig: string, authPub: Buffer,
+): boolean {
+    try {
+        return crypto.verify(
+            null, Buffer.from(requestSigString(method, urlPath, ts, body), "utf8"),
+            publicKeyFromRaw(authPub), Buffer.from(sig, "base64url"),
+        );
+    } catch { return false; }
+}
@@ -6,6 +6,9 @@ import path     from "path";
 import fs       from "fs";
 import crypto   from "crypto";
 import axios    from "axios";
+import Database from "better-sqlite3";
+import { createSub } from "./sub";
+import { createNodes } from "./nodes";

 const app  = express();
 const PORT = Number(process.env.PORT) || 8080;
@@ -50,6 +53,46 @@ function mintInternalToken(): string {

 const revoked = new Set<string>();

+// ── Ключи внешнего API (/api/v1) ───────────────────────────────────────────
+// Живут в собственной БД awg-ui: awg-ctrl про них ничего не знает. Открытое
+// значение ключа не хранится — только SHA-256 и префикс для показа в панели.
+interface ApiKeyRow {
+    id: number; label: string; key_hash: string; prefix: string;
+    server_id: number; created_at: number; last_used: number | null;
+}
+
+const UI_DB_FILE = process.env.UI_DB_FILE || path.join(__dirname, "ui.db");
+const uidb = new Database(UI_DB_FILE);
+uidb.pragma("journal_mode = WAL");
+uidb.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
+    )
+`);
+
+const keyStmts = {
+    list:   uidb.prepare("SELECT id, label, prefix, server_id, created_at, last_used FROM api_keys ORDER BY id"),
+    insert: uidb.prepare("INSERT INTO api_keys (label, key_hash, prefix, server_id, created_at) VALUES (?, ?, ?, ?, ?)"),
+    delete: uidb.prepare<[number]>("DELETE FROM api_keys WHERE id = ?"),
+    byHash: uidb.prepare<[string]>("SELECT * FROM api_keys WHERE key_hash = ?"),
+    touch:  uidb.prepare<[number, number]>("UPDATE api_keys SET last_used = ? WHERE id = ?"),
+};
+
+function hashKey(key: string): string {
+    return crypto.createHash("sha256").update(key).digest("hex");
+}
+
+function genApiKey(): { key: string; hash: string; prefix: string } {
+    const key = "awgk_" + crypto.randomBytes(24).toString("base64url");
+    return { key, hash: hashKey(key), prefix: key.slice(0, 13) + "…" };
+}
+
 function tokenSig(token: string): string { return token.split(".")[2] ?? token; }

 function sign(): string {
@@ -128,21 +171,61 @@ app.get("/ui/brand", (_req: Request, res: Response) => {
    res.json({ brand: BRAND, channel: CHANNEL, version: VERSION });
 });

+// Управление ключами внешнего API — роуты самой awg-ui, в awg-ctrl не идут.
+app.get("/ui/apikeys", requireAuth, (_req: Request, res: Response) => {
+    res.json({ keys: keyStmts.list.all() });
+});
+
+app.post("/ui/apikeys", requireAuth, (req: Request, res: Response) => {
+    const { label, server_id } = req.body as { label?: string; server_id?: number };
+    if (!label || !/^[\w \-]{1,40}$/.test(label)) {
+        res.status(400).json({ error: "Метка: буквы, цифры, пробел, _ и -, до 40 символов" }); return;
+    }
+    const sid = server_id === undefined ? nodes.defaultId() : Number(server_id);
+    if (!Number.isInteger(sid) || !nodes.exists(sid)) { res.status(400).json({ error: "Такого сервера нет" }); return; }
+    const { key, hash, prefix } = genApiKey();
+    const info = keyStmts.insert.run(label, hash, prefix, sid, Math.floor(Date.now() / 1000));
+    // Открытое значение отдаётся один раз — дальше в БД только хэш.
+    res.status(201).json({ id: info.lastInsertRowid, label, prefix, key });
+});
+
+app.delete("/ui/apikeys/:id", requireAuth, (req: Request, res: Response) => {
+    const id = Number(req.params.id);
+    if (!Number.isInteger(id)) { res.status(400).json({ error: "Неверный id" }); return; }
+    keyStmts.delete.run(id);
+    res.json({ success: true, id });
+});
+
+// Сервер, к которому относится запрос панели: заголовок X-Server-Id (0 — локальный
+// awg-ctrl, остальное — нода). Без заголовка — сервер по умолчанию.
+function serverIdOf(req: Request): number {
+    const raw = req.headers["x-server-id"];
+    if (raw === undefined) return nodes.defaultId();
+    const n = Number(raw);
+    return Number.isInteger(n) && n >= 0 ? n : nodes.defaultId();
+}
+
 async function proxy(req: Request, res: Response) {
    try {
-        const r = await axios({
-            method: req.method,
-            url:    CTRL + req.originalUrl,
-            headers: { Authorization: `Bearer ${mintInternalToken()}`, "Content-Type": "application/json" },
-            data:   req.body,
-            validateStatus: () => true,
-        });
+        const r = await nodes.ctrlFor(serverIdOf(req))(req.method, req.originalUrl, req.body);
        res.status(r.status).json(r.data);
    } catch {
        res.status(502).json({ error: "awg-ctrl недоступен" });
    }
 }

+interface ExtRequest extends Request { apiKey?: ApiKeyRow; }
+
+function requireApiKey(req: Request, res: Response, next: NextFunction) {
+    const key = (req.headers["x-api-key"] as string) ?? "";
+    if (!key.startsWith("awgk_")) { res.status(401).json({ error: "API key required" }); return; }
+    const row = keyStmts.byHash.get(hashKey(key)) as ApiKeyRow | undefined;
+    if (!row) { res.status(401).json({ error: "Invalid API key" }); return; }
+    keyStmts.touch.run(Math.floor(Date.now() / 1000), row.id);
+    (req as ExtRequest).apiKey = row;
+    next();
+}
+
 async function ctrl(method: string, urlPath: string, body?: unknown) {
    return axios({
        method,
@@ -153,6 +236,64 @@ async function ctrl(method: string, urlPath: string, body?: unknown) {
    });
 }

+// Внешний контракт: наружу отдаём только name/ip/gen/vpn_key — psk_key и pub_key
+// остаются внутри. gen — поколение AmneziaWG, на параметрах которого выдан ключ.
+interface ExtUser { name: string; ip: string; vpn_key: string; key_gen: string }
+
+const ext = express.Router();
+ext.use(requireApiKey);
+
+// Ключ привязан к server_id — все вызовы уходят на его сервер.
+const ctrlOf = (req: Request) => nodes.ctrlFor((req as ExtRequest).apiKey?.server_id ?? 0);
+
+// Express 4 не ловит отказы async-обработчиков: незакрытый reject (awg-ctrl не
+// отвечает, внутренний ключ не загружен) уронил бы весь процесс панели. Ответ
+// тот же, что у proxy() в такой ситуации.
+type Handler = (req: Request, res: Response) => Promise<void>;
+const wrap = (fn: Handler) => (req: Request, res: Response) => {
+    fn(req, res).catch(() => { res.status(502).json({ error: "awg-ctrl недоступен" }); });
+};
+
+ext.post("/users", wrap(async (req, res) => {
+    const { name } = (req.body ?? {}) as { name?: string };
+    const r = await ctrlOf(req)("POST", "/api/users", { name });
+    if (r.status >= 400) { res.status(r.status).json(r.data); return; }
+    const u = r.data as ExtUser;
+    res.status(201).json({ name: u.name, ip: u.ip, gen: u.key_gen, vpn_key: u.vpn_key });
+}));
+
+ext.get("/users", wrap(async (req, res) => {
+    const r = await ctrlOf(req)("GET", "/api/users/stats");
+    res.status(r.status).json(r.data);
+}));
+
+ext.get("/users/:name", wrap(async (req, res) => {
+    const r = await ctrlOf(req)("POST", `/api/users/${encodeURIComponent(req.params.name)}`);
+    if (r.status >= 400) { res.status(r.status).json(r.data); return; }
+    const u = r.data as ExtUser;
+    res.json({ name: u.name, ip: u.ip, gen: u.key_gen, vpn_key: u.vpn_key });
+}));
+
+ext.delete("/users/:name", wrap(async (req, res) => {
+    const r = await ctrlOf(req)("DELETE", `/api/users/${encodeURIComponent(req.params.name)}`);
+    res.status(r.status).json(r.data);
+}));
+
+// ВАЖНО: /api/v1 монтируется ДО JWT-прокси на /api — иначе прокси перехватит
+// его и потребует JWT вместо ключа.
+app.use("/api/v1", ext);
+
+// sen://-подписка: мастер-ключи и устройства (роуты панели, за JWT) и публичный
+// листенер /sub/v1 на своём порту SUB_PORT. Публичная часть сюда не монтируется.
+// Несколько серверов: core (эта панель) + ноды по исходящему WSS. Реестр — в ui.db.
+const nodes = createNodes({ uidb, ctrlLocal: ctrl, baseDir: __dirname });
+app.use("/ui/nodes", requireAuth, nodes.router);
+
+// sen://-подписка: мастер-ключ отдаёт набор серверов (локальный и/или ноды).
+const sub = createSub({ uidb, servers: nodes, baseDir: __dirname });
+app.use("/ui/masterkeys", requireAuth, sub.masterKeys);
+app.use("/ui/devices",    requireAuth, sub.devices);
+
 app.use(["/api", "/health", "/awg"], requireAuth, proxy);

 app.use(express.static(path.join(__dirname, "dist")));
@@ -162,3 +303,5 @@ app.get("*", (_req: Request, res: Response) => {
 });

 app.listen(PORT, () => { console.log(`ui: listening on :${PORT}`); });
+nodes.start();
+sub.start();
@@ -24,6 +24,7 @@ html, body, #root { height: 100%; }
    --success-bg:   #c0dd97; --success-text: #2c4d0a; --success-dot: #639922;
    --neutral-bg:   #e4dac9; --neutral-text: #7a6a55; --neutral-dot:  #a99a85;
    --error-bg:     #ffdad6; --error-text:   #410002; --error-dot:    #ba1a1a;
+    --warn-dot:     #e08a2c;

    --danger-border: #e6c4bc;
    --danger-text:   #b34a3a;
@@ -65,6 +66,7 @@ html, body, #root { height: 100%; }
    --success-bg:   #2d4413; --success-text: #c8e3a0; --success-dot: #8fc24f;
    --neutral-bg:   #34291c; --neutral-text: #d0c0a4; --neutral-dot:  #b0a085;
    --error-bg:     #5c1414; --error-text:   #ffb4ab; --error-dot:    #ff5449;
+    --warn-dot:     #ffb76b;

    --danger-border: #6e4540;
    --danger-text:   #ffb4ab;
@@ -373,6 +375,7 @@ body {
 .server-bar {
    display: flex;
    align-items: center;
+    flex-wrap: wrap;
    gap: 8px;
 }
 .server-card {
@@ -387,6 +390,45 @@ body {
    user-select: none;
 }
 .server-card--active { border-color: var(--primary-container); }
+.server-card--inactive { cursor: pointer; }
+.server-card--inactive:hover { background: var(--state-primary); }
+.server-card:focus-visible { outline: 2px solid var(--primary); outline-offset: 2px; }
+
+/* «Добавить сервер»: призрачная кнопка с пунктиром (design.md, 4.2) */
+.server-add {
+    background: transparent;
+    border: 1.5px dashed var(--outline);
+    color: var(--neutral-text);
+}
+.server-add:disabled { opacity: .6; cursor: not-allowed; }
+
+/* Модалка добавления ноды */
+.node-scrim {
+    position: fixed; inset: 0; z-index: 60;
+    background: var(--scrim);
+    display: flex; align-items: center; justify-content: center;
+    padding: 16px;
+}
+.node-modal {
+    width: 100%; max-width: 520px;
+    background: var(--surface-bright);
+    border: 1px solid var(--outline-variant);
+    border-radius: var(--r-card);
+    padding: 20px;
+    display: flex; flex-direction: column; gap: 12px;
+}
+.node-modal-title { margin: 0; font-size: 16px; font-weight: 500; color: var(--on-surface); }
+.node-modal-hint  { margin: 0; font-size: 12px; color: var(--neutral-text); }
+.node-modal-cmd {
+    display: block;
+    font-family: var(--mono); font-size: 12px;
+    background: var(--surface-container);
+    border-radius: var(--r-table);
+    padding: 12px;
+    word-break: break-all;
+    user-select: all;
+}
+.node-modal-actions { display: flex; gap: 8px; justify-content: flex-end; flex-wrap: wrap; }
 .server-card-info {
    display: flex;
    flex-direction: column;
@@ -654,6 +696,9 @@ tbody td:last-child  { padding-right: 20px; }
        border-color: var(--primary-container);
        padding: 12px 14px;
    }
+    .server-card--inactive { border-color: var(--outline-variant); }
+    .server-add { width: 100%; justify-content: center; }
+    .node-modal-actions .btn { flex: 1; }
    .server-toggle       { display: flex; }
    .server-online-chip  { display: none; }

@@ -4,20 +4,27 @@
 import { useState, useEffect, useRef, useCallback } from 'react';
 import axios from 'axios';
 import './App.css';
-import { TOKEN_KEY, THEME_KEY, BRAND_FALLBACK, apiFetch, type ServerInfo, type Brand } from './lib/shared';
+import {
+    TOKEN_KEY, THEME_KEY, SERVER_KEY, BRAND_FALLBACK, apiFetch, setServerId, getServerId,
+    type NodeInfo, type Brand,
+} from './lib/shared';
 import { IcoMenu, IcoLogout, IcoSun, IcoMoon, IcoRefresh } from './components/icons';
 import ServerBar from './components/ServerBar';
+import AddServerModal from './components/AddServerModal';
 import { TABS } from './tabs';

 // Оболочка приложения: логин, тема, drawer/сайдбар, общая сессия (token,
-// serverInfo, снэкбар) и переключение вкладок. Контент каждой вкладки приходит
+// список серверов и выбранный сервер, снэкбар) и переключение вкладок. Контент каждой вкладки приходит
 // из реестра TABS — App про конкретные вкладки ничего не знает.
 export default function App() {
    const [token, setToken]           = useState(() => localStorage.getItem(TOKEN_KEY) ?? '');
    const [loginUser, setLoginUser]   = useState('');
    const [loginPass, setLoginPass]   = useState('');
    const [statusText, setStatusText] = useState('');
-    const [serverInfo, setServerInfo] = useState<ServerInfo | null>(null);
+    const [nodes, setNodes]           = useState<NodeInfo[]>([]);
+    const [hubEnabled, setHubEnabled] = useState(false);
+    const [serverId, setServerIdState] = useState<number | null>(null);
+    const [modal, setModal]           = useState<{ node?: NodeInfo } | null>(null);
    const [msg, setMsg]               = useState('');
    const [drawerOpen, setDrawerOpen] = useState(false);
    const [activeTab, setActiveTab]   = useState(TABS[0].id);
@@ -33,17 +40,34 @@ export default function App() {
        setTimeout(() => setMsg(''), 3000);
    }, []);

-    // Проверяет токен и подтягивает данные сервера (/health). Данные конкретных
-    // вкладок (юзеры, ключи) грузят сами вкладки.
-    const startSession = useCallback(async (tok: string) => {
-        const { data: h } = await axios.get('/health', { headers: { Authorization: `Bearer ${tok}` } });
-        setServerInfo({
-            name: h.server || 'VPN', ip: h.ip || '', peers: h.awg?.peers ?? 0, gen: h.gen || '2',
-            mod: h.awg?.module ?? '', tools: h.awg?.tools ?? '',
-        });
-        setStatusText('online:' + (h.server || 'ok') + ' · peers: ' + (h.awg?.peers ?? '?'));
+    // Выбрать сервер: id уходит заголовком X-Server-Id во все запросы вкладок
+    // (setServerId — до смены state, чтобы вкладка с новым key читала уже с ним).
+    const pickServer = useCallback((id: number | null) => {
+        setServerId(id);
+        setServerIdState(id);
+        try { if (id !== null) localStorage.setItem(SERVER_KEY, String(id)); } catch { /* не критично */ }
    }, []);

+    // Список серверов (core + ноды) с их состоянием. Если выбранного больше нет —
+    // берём сохранённый, иначе первый.
+    const loadNodes = useCallback(async (tok: string) => {
+        const { data } = await axios.get('/ui/nodes', { headers: { Authorization: `Bearer ${tok}` } });
+        const list: NodeInfo[] = data.nodes ?? [];
+        setNodes(list);
+        setHubEnabled(!!data.hub);
+        const cur = getServerId();
+        if (cur !== null && list.some(n => n.id === cur)) return;
+        let saved: number | null = null;
+        try { const raw = localStorage.getItem(SERVER_KEY); saved = raw === null ? null : Number(raw); } catch { /* не критично */ }
+        pickServer(list.find(n => n.id === saved)?.id ?? list[0]?.id ?? null);
+    }, [pickServer]);
+
+    // Проверяет токен и подтягивает список серверов. Данные конкретных вкладок
+    // (юзеры, ключи) грузят сами вкладки.
+    const startSession = useCallback(async (tok: string) => {
+        await loadNodes(tok);
+    }, [loadNodes]);
+
    const login = useCallback(async () => {
        try {
            const { data: auth } = await axios.post('/login', { user: loginUser, pass: loginPass });
@@ -69,10 +93,23 @@ export default function App() {
        localStorage.removeItem(TOKEN_KEY);
        setToken('');
        setStatusText('');
-        setServerInfo(null);
+        setNodes([]);
+        setServerId(null);
+        setServerIdState(null);
        setDrawerOpen(false);
    }, [token]);

+    const deleteNode = useCallback(async (n: NodeInfo) => {
+        if (!confirm(`Удалить сервер «${n.name}»? Нода отключится от панели.`)) return;
+        try {
+            await apiFetch('DELETE', `/ui/nodes/${n.id}`, token);
+            showMsg('Сервер удалён');
+            await loadNodes(token);
+        } catch (e) {
+            showMsg(axios.isAxiosError(e) ? e.response?.data?.error ?? 'Не удалось удалить' : 'Не удалось удалить');
+        }
+    }, [token, showMsg, loadNodes]);
+
    // Перезапуск AWG-интерфейса (awg-quick down/up + ресинк пиров в awg-ctrl).
    // Соединения клиентов кратковременно прерываются — поэтому подтверждение.
    const restartAwg = useCallback(async () => {
@@ -111,6 +148,13 @@ export default function App() {
        }
    }, [startSession]);

+    // Состояние серверов (онлайн, пиры) обновляем раз в 15 с, пока открыта панель.
+    useEffect(() => {
+        if (!token) return;
+        const t = setInterval(() => { loadNodes(token).catch(() => { /* следующий тик */ }); }, 15_000);
+        return () => clearInterval(t);
+    }, [token, loadNodes]);
+
    // Имя продукта и версия — с сервера, до логина (роут без авторизации).
    // Если не ответил, остаётся фолбэк из констант.
    useEffect(() => {
@@ -143,8 +187,7 @@ export default function App() {
        return () => document.removeEventListener('keydown', h);
    }, [drawerOpen]);

-    const isOnline = statusText.startsWith('online:');
-    const statusLabel = statusText.replace(/^(online|offline):/, '');
+        const statusLabel = statusText.replace(/^(online|offline):/, '');
    const tab = TABS.find(t => t.id === activeTab) ?? TABS[0];
    // Хром вкладки (сервер-бар + перезапуск). Любой флаг по умолчанию включён.
    const chrome = tab.chrome ?? {};
@@ -161,7 +204,7 @@ export default function App() {
                {theme === 'dark' ? <IcoSun /> : <IcoMoon />}
            </button>

-            {token && showRestart && (
+            {token && showRestart && serverId !== null && (
                <button
                    className={`awg-restart${restarting ? ' spinning' : ''}`}
                    aria-label="Перезапустить AWG"
@@ -257,19 +300,41 @@ export default function App() {
                            {/* Общий хром над вкладкой — App владеет им сам, вкладки про него не знают */}
                            {showServerBar && (
                                <ServerBar
-                                    serverInfo={serverInfo}
-                                    serverOnline={isOnline}
+                                    nodes={nodes}
+                                    serverId={serverId}
+                                    hubEnabled={hubEnabled}
+                                    onSelect={pickServer}
+                                    onAdd={() => setModal({})}
+                                    onJoin={n => setModal({ node: n })}
+                                    onDelete={deleteNode}
                                    onRestartAwg={restartAwg}
                                    restarting={restarting}
                                    showRestart={showRestart}
                                />
                            )}
-                            <tab.Page token={token} showMsg={showMsg} />
+                            {serverId === null && showServerBar ? (
+                                <p className="login-sub">
+                                    Серверов пока нет. Добавьте ноду: она сама подключится к этой панели.
+                                </p>
+                            ) : (
+                                // key: при смене сервера вкладка монтируется заново и читает данные уже с ним
+                                <tab.Page key={`${tab.id}:${serverId}`} token={token} showMsg={showMsg} />
+                            )}
                        </main>
                    </div>
                </>
            )}

+            {modal && (
+                <AddServerModal
+                    token={token}
+                    node={modal.node}
+                    onClose={() => setModal(null)}
+                    onChanged={() => { loadNodes(token).catch(() => { /* следующий тик */ }); }}
+                    showMsg={showMsg}
+                />
+            )}
+
            {msg && <div className="snack">{msg}</div>}
        </div>
    );
@@ -0,0 +1,102 @@
+// 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, copyText, type NodeInfo } from '../lib/shared';
+import { IcoCopy } from './icons';
+
+interface Joined { id: number; name: string; join: string; expires_in: number }
+
+// Добавление ноды: имя → одноразовая join-строка, которую выполняют на самой ноде
+// (`awg-ctrl join …`). С `node` открывается сразу за новой строкой для уже
+// созданной, но ещё не подключавшейся ноды.
+export default function AddServerModal({ token, node, onClose, onChanged, showMsg }: {
+    token:     string;
+    node?:     NodeInfo;
+    onClose:   () => void;
+    onChanged: () => void;
+    showMsg:   (text: string) => void;
+}) {
+    const [name, setName]     = useState('');
+    const [busy, setBusy]     = useState(false);
+    const [result, setResult] = useState<Joined | null>(null);
+    const [error, setError]   = useState('');
+
+    const call = async (fn: () => Promise<Joined>) => {
+        setBusy(true); setError('');
+        try { setResult(await fn()); onChanged(); }
+        catch (e) { setError(axios.isAxiosError(e) ? e.response?.data?.error ?? 'Не удалось' : 'Не удалось'); }
+        finally { setBusy(false); }
+    };
+    const create = () => call(() =>
+        apiFetch('POST', '/ui/nodes', token, { name: name.trim(), host: window.location.hostname }));
+
+    useEffect(() => {
+        if (node) void call(() => apiFetch('POST', `/ui/nodes/${node.id}/join`, token, { host: window.location.hostname }));
+        // eslint-disable-next-line react-hooks/exhaustive-deps
+    }, []);
+
+    useEffect(() => {
+        const h = (e: KeyboardEvent) => { if (e.key === 'Escape') onClose(); };
+        document.addEventListener('keydown', h);
+        return () => document.removeEventListener('keydown', h);
+    }, [onClose]);
+
+    const command = result ? `awg-ctrl join '${result.join}'` : '';
+
+    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 ? `Подключение: ${node.name}` : 'Добавить сервер'}</h3>
+
+                {!node && !result && (
+                    <>
+                        <p className="node-modal-hint">
+                            Нода — обычный сервер с установленным Forgetting. Она сама подключится к этой панели,
+                            открывать на ней порты не нужно.
+                        </p>
+                        <input
+                            className="field"
+                            placeholder="Название сервера"
+                            value={name}
+                            maxLength={40}
+                            autoFocus
+                            onChange={e => setName(e.target.value)}
+                            onKeyDown={e => e.key === 'Enter' && name.trim() && !busy && create()}
+                        />
+                    </>
+                )}
+
+                {result && (
+                    <>
+                        <p className="node-modal-hint">
+                            Выполните на сервере «{result.name}» от root. Ссылка одноразовая и действует
+                            {' '}{Math.round(result.expires_in / 60)} мин.
+                        </p>
+                        <code className="node-modal-cmd">{command}</code>
+                        <p className="node-modal-hint">
+                            Канал шифруется TLS с проверкой отпечатка сертификата этой панели: подменить ноду
+                            или панель по дороге не выйдет.
+                        </p>
+                    </>
+                )}
+
+                {error && <p className="login-error">{error}</p>}
+
+                <div className="node-modal-actions">
+                    {result ? (
+                        <button className="btn btn--tonal" onClick={() => copyText(command).then(() => showMsg('Команда скопирована'))}>
+                            <IcoCopy /> Скопировать
+                        </button>
+                    ) : !node && (
+                        <button className="btn btn--primary" onClick={create} disabled={busy || !name.trim()}>
+                            Создать
+                        </button>
+                    )}
+                    <button className="btn btn--outline" onClick={onClose}>{result ? 'Готово' : 'Отмена'}</button>
+                </div>
+            </div>
+        </div>
+    );
+}
@@ -1,56 +1,104 @@
 // 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 ServerInfo, genLabel } from '../lib/shared';
-import { IcoRefresh } from './icons';
+import { type NodeInfo, genLabel } from '../lib/shared';
+import { IcoRefresh, IcoPlus, IcoTrash, IcoCopy } from './icons';

-// Сервер-бар: карточка активного сервера + (на мобильной) перезапуск AWG под
-// ней. Общий для вкладок — показывает сервер, к которому относится содержимое
-// вкладки (пиры / абоненты).
+// Сервер-бар: карточки серверов (core-локальный и ноды) + «Добавить сервер» и
+// (на мобильной) перезапуск AWG под ними. Общий для вкладок — показывает
+// серверы, между которыми переключается содержимое вкладки (пиры / абоненты).
 export default function ServerBar({
-    serverInfo, serverOnline, onRestartAwg, restarting,
-    showRestart = true,
+    nodes, serverId, hubEnabled, onSelect, onAdd, onJoin, onDelete,
+    onRestartAwg, restarting, showRestart = true,
 }: {
-    serverInfo: ServerInfo | null;
-    serverOnline: boolean;
+    nodes: NodeInfo[];
+    serverId: number | null;
+    hubEnabled: boolean;
+    onSelect: (id: number) => void;
+    onAdd: () => void;
+    onJoin: (n: NodeInfo) => void;
+    onDelete: (n: NodeInfo) => void;
    onRestartAwg: () => void;
    restarting: boolean;
    showRestart?: boolean;
 }) {
    return (
        <div className="server-bar">
-            {serverInfo && (
-                <div className="server-card server-card--active">
-                    {/* toggle — виден на мобильном вместо чипа */}
+            {nodes.map(n => {
+                const h = n.health;
+                const active = n.id === serverId;
+                return (
                    <div
-                        className={`server-toggle${serverOnline ? ' server-toggle--on' : ''}`}
-                        aria-hidden="true"
+                        key={n.id}
+                        className={`server-card server-card--${active ? 'active' : 'inactive'}`}
+                        role="button"
+                        tabIndex={0}
+                        aria-pressed={active}
+                        onClick={() => onSelect(n.id)}
+                        onKeyDown={e => { if (e.key === 'Enter' || e.key === ' ') { e.preventDefault(); onSelect(n.id); } }}
                    >
-                        <div className="server-toggle-thumb" />
-                    </div>
-                    {/* чип онлайн/офлайн — виден на десктопе */}
-                    <span className={`chip chip--${serverOnline ? 'online' : 'offline'} server-online-chip`}>
-                        <span className="chip-dot" />
-                    </span>
-                    <div className="server-card-info">
-                        <span className="server-card-name">{serverInfo.name}</span>
-                        <span className="server-card-ip">{serverInfo.ip}</span>
-                        {(serverInfo.mod || serverInfo.tools) ? (
-                            <span
-                                className="tip-wrap server-gen-wrap"
-                                data-tip={`модуль ${serverInfo.mod || '?'} · tools ${serverInfo.tools || '?'}`}
+                        {/* toggle — виден на мобильном вместо чипа */}
+                        <div className={`server-toggle${n.online ? ' server-toggle--on' : ''}`} aria-hidden="true">
+                            <div className="server-toggle-thumb" />
+                        </div>
+                        {/* чип онлайн/офлайн — виден на десктопе */}
+                        <span className={`chip chip--${n.online ? 'online' : 'offline'} server-online-chip`}>
+                            <span className="chip-dot" />
+                        </span>
+                        <div className="server-card-info">
+                            <span className="server-card-name">{h?.server || n.name}</span>
+                            {n.pending ? (
+                                <span className="server-card-ip">ждёт подключения</span>
+                            ) : !n.online ? (
+                                <span className="server-card-ip">нет связи</span>
+                            ) : h && (
+                                <>
+                                    <span className="server-card-ip">{h.ip}</span>
+                                    {(h.module || h.tools) ? (
+                                        <span
+                                            className="tip-wrap server-gen-wrap"
+                                            data-tip={`модуль ${h.module || '?'} · tools ${h.tools || '?'}`}
+                                        >
+                                            <span className="chip chip--offline server-gen-chip">{genLabel(h.gen)}</span>
+                                        </span>
+                                    ) : (
+                                        <span className="chip chip--offline server-gen-chip">{genLabel(h.gen)}</span>
+                                    )}
+                                </>
+                            )}
+                        </div>
+                        {h && n.online && <span className="server-card-peers">{h.peers} peers</span>}
+                        {n.pending && (
+                            <button
+                                className="btn-icon btn-icon--neutral"
+                                aria-label="Новая ссылка подключения"
+                                onClick={e => { e.stopPropagation(); onJoin(n); }}
                            >
-                                <span className="chip chip--offline server-gen-chip">{genLabel(serverInfo.gen)}</span>
-                            </span>
-                        ) : (
-                            <span className="chip chip--offline server-gen-chip">{genLabel(serverInfo.gen)}</span>
+                                <IcoCopy />
+                            </button>
+                        )}
+                        {!n.local && (
+                            <button
+                                className="btn-icon btn-icon--danger"
+                                aria-label={`Удалить сервер ${n.name}`}
+                                onClick={e => { e.stopPropagation(); onDelete(n); }}
+                            >
+                                <IcoTrash />
+                            </button>
                        )}
                    </div>
-                    <span className="server-card-peers">{serverInfo.peers} peers</span>
-                </div>
-            )}
+                );
+            })}
+            <span
+                className="tip-wrap"
+                data-tip={hubEnabled ? '' : 'Приём нод выключен: задайте NODE_PORT'}
+            >
+                <button className="btn server-add" onClick={onAdd} disabled={!hubEnabled}>
+                    <IcoPlus /> Добавить сервер
+                </button>
+            </span>
            {/* Перезапуск AWG — только на мобильной (на десктопе кнопка в углу). */}
-            {showRestart && (
+            {showRestart && serverId !== null && (
                <button
                    className={`btn btn--tonal awg-restart-mobile${restarting ? ' spinning' : ''}`}
                    onClick={onRestartAwg}
@@ -35,6 +35,13 @@ export const IcoRefresh = () => (
        <path d="M20.49 15a9 9 0 1 1-2.12-9.36L23 10"/>
    </svg>
 );
+export const IcoSettings = () => (
+    <svg width="15" height="15" viewBox="0 0 24 24" fill="none" stroke="currentColor" strokeWidth="2" strokeLinecap="round">
+        <line x1="4" y1="7" x2="20" y2="7"/><line x1="4" y1="17" x2="20" y2="17"/>
+        <circle cx="9" cy="7" r="2.5" fill="var(--surface-bright, transparent)"/>
+        <circle cx="15" cy="17" r="2.5" fill="var(--surface-bright, transparent)"/>
+    </svg>
+);
 export const IcoQR = () => (
    <svg width="15" height="15" viewBox="0 0 24 24" fill="none" stroke="currentColor" strokeWidth="2" strokeLinecap="round" strokeLinejoin="round">
        <rect x="3" y="3" width="7" height="7" rx="1"/><rect x="14" y="3" width="7" height="7" rx="1"/>
@@ -26,6 +26,16 @@ export interface ServerInfo {
 }
 // На проводе (users.key_gen, /health gen) поколение — '2', человеку показываем '2.0'.
 export const genLabel = (g: AwgGen): string => (g === '3.1' ? 'AWG 3.1' : 'AWG 2.0');
+// Ключ внешнего API в списке вкладки: открытого значения тут нет — только
+// префикс, сервер хранит лишь хэш.
+export interface ApiKey {
+    id:         number;
+    label:      string;
+    prefix:     string;
+    server_id:  number;
+    created_at: number;
+    last_used:  number | null;
+}

 export interface PageProps {
    token:   string;
@@ -37,10 +47,32 @@ export interface PageProps {
 export const BRAND_FALLBACK = 'Forgetting';
 export interface Brand { brand: string; channel: string; version: string }

-export const TOKEN_KEY = 'awg_token';
-export const THEME_KEY = 'awg_theme';
+export const TOKEN_KEY  = 'awg_token';
+export const THEME_KEY  = 'awg_theme';
+export const SERVER_KEY = 'awg_server';
+
+// Сервер (core или нода) в списке ServerBar: то, что отдаёт GET /ui/nodes.
+export interface NodeInfo {
+    id:        number;
+    name:      string;
+    local:     boolean;        // id 0 — локальный awg-ctrl этой же машины
+    online:    boolean;
+    pending:   boolean;        // нода создана, но ещё ни разу не подключалась
+    last_seen: number | null;
+    health:    { server: string; ip: string; gen: AwgGen; peers: number; awg_up: boolean; module: string; tools: string } | null;
+}
+
+// Выбранный сервер. Вкладки зовут apiFetch без явного id — заголовок X-Server-Id
+// подставляется здесь; App ставит значение до смены key у вкладки, поэтому та
+// перечитывает данные уже с новым сервером.
+let currentServerId: number | null = null;
+export const setServerId = (id: number | null) => { currentServerId = id; };
+export const getServerId = () => currentServerId;
+
 export async function apiFetch(method: string, path: string, token: string, body?: object): Promise<any> {
-    const r = await axios({ method, url: path, headers: { Authorization: `Bearer ${token}` }, data: body });
+    const headers: Record<string, string> = { Authorization: `Bearer ${token}` };
+    if (currentServerId !== null) headers['X-Server-Id'] = String(currentServerId);
+    const r = await axios({ method, url: path, headers, data: body });
    return r.data;
 }

@@ -0,0 +1,77 @@
+/*
+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.
+*/
+/* Стили вкладки «API-ключи». Общая дизайн-система — в App.css. */
+
+/* Открытый API-ключ (показывается один раз при создании) */
+.apikey-value {
+    font-family: var(--mono);
+    font-size: 13px;
+    color: var(--on-surface);
+    background: var(--surface-container);
+    border: 1px solid var(--outline-variant);
+    border-radius: 12px;
+    padding: 12px 14px;
+    width: 100%;
+    word-break: break-all;
+    user-select: all;
+}
+
+.apikey-cards-list { display: none; flex-direction: column; gap: 12px; }
+
+.apikey-count { font-size: 12px; color: var(--neutral-text); }
+.apikey-empty {
+    font-size: 14px;
+    color: var(--neutral-text);
+    text-align: center;
+    padding: 48px 0;
+}
+.apikey-card {
+    background: var(--surface-bright);
+    border: 1px solid var(--outline-variant);
+    border-radius: var(--r-card);
+    padding: 16px;
+    display: flex;
+    flex-direction: column;
+    gap: 12px;
+}
+.apikey-card-header {
+    display: flex;
+    align-items: center;
+    justify-content: space-between;
+    gap: 8px;
+}
+.apikey-card-title {
+    display: flex;
+    align-items: baseline;
+    gap: 8px;
+    min-width: 0;
+}
+.apikey-card-num   { font-size: 12px; color: var(--neutral-dot); flex-shrink: 0; }
+.apikey-card-label {
+    font-size: 16px;
+    font-weight: 500;
+    color: var(--on-surface);
+    overflow: hidden;
+    text-overflow: ellipsis;
+    white-space: nowrap;
+}
+.apikey-card-prefix {
+    font-family: var(--mono);
+    font-size: 13px;
+    color: var(--neutral-text);
+    word-break: break-all;
+}
+.apikey-card-meta {
+    display: flex;
+    justify-content: space-between;
+    gap: 8px;
+    font-size: 12px;
+    color: var(--neutral-text);
+}
+
+@media (max-width: 640px) {
+    .apikey-cards-list { display: flex; }
+}
@@ -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.
+import { useState, useEffect, useCallback } from 'react';
+import { apiFetch, copyText, timeAgo, getServerId, type ApiKey, type PageProps } from '../../lib/shared';
+import { IcoPlus, IcoTrash, IcoCopy } from '../../components/icons';
+import './apikeys.css';
+
+// Вкладка «API-ключи»: ключи внешнего API (/api/v1). Открытый ключ показывается
+// один раз при создании (в БД хранится только хэш). Сервер-бар сверху рендерит App.
+//   TODO multi-server: сейчас сервер один (server_id = 0). Когда появится список
+//   серверов — ключ будет привязываться к выбранному в сервер-баре.
+export default function ApiKeysPage({ token, showMsg }: PageProps) {
+    const [keys, setKeys]       = useState<ApiKey[]>([]);
+    const [label, setLabel]     = useState('');
+    const [created, setCreated] = useState<{ label: string; key: string } | null>(null);
+
+    const load = useCallback(async () => {
+        try {
+            const data = await apiFetch('GET', '/ui/apikeys', token);
+            setKeys(data.keys ?? []);
+        } catch {
+            showMsg('Ошибка загрузки ключей');
+        }
+    }, [token, showMsg]);
+
+    const createKey = useCallback(async () => {
+        if (!label.trim()) return;
+        const r = await apiFetch('POST', '/ui/apikeys', token, { label: label.trim(), server_id: getServerId() ?? 0 });
+        if (r.error) { showMsg(r.error); return; }
+        setLabel('');
+        setCreated({ label: r.label, key: r.key });
+        await load();
+    }, [label, token, load, showMsg]);
+
+    const deleteKey = useCallback(async (id: number, lbl: string) => {
+        if (!confirm('Удалить ключ «' + lbl + '»? Клиенты с ним потеряют доступ.')) return;
+        await apiFetch('DELETE', '/ui/apikeys/' + id, token);
+        showMsg('Ключ удалён: ' + lbl);
+        await load();
+    }, [token, load, showMsg]);
+
+    useEffect(() => { if (token) load(); }, [token, load]);
+
+    return (
+        <>
+            {/* Сервер-бар сверху рендерит App; к выбранному в нём серверу и привязывается ключ.
+                TODO multi-server: server_id берётся из выбранной карточки (пока 0). */}
+            <div className="toolbar">
+                <input
+                    className="field"
+                    placeholder="Метка ключа (напр. ci-bot)"
+                    value={label}
+                    onChange={e => setLabel(e.target.value)}
+                    onKeyDown={e => e.key === 'Enter' && createKey()}
+                />
+                <div className="toolbar-btns">
+                    <button className="btn btn--primary" onClick={createKey}>
+                        <IcoPlus /> Создать ключ
+                    </button>
+                </div>
+            </div>
+
+            <div className="table-card">
+                <table>
+                    <thead>
+                        <tr>
+                            <th>#</th>
+                            <th>Метка</th>
+                            <th>Ключ</th>
+                            <th>Создан</th>
+                            <th>Последний раз</th>
+                            <th></th>
+                        </tr>
+                    </thead>
+                    <tbody>
+                        {keys.length === 0 ? (
+                            <tr><td colSpan={6} className="empty">Нет ключей</td></tr>
+                        ) : keys.map((k, i) => (
+                            <tr key={k.id}>
+                                <td className="td-num">{i + 1}</td>
+                                <td>{k.label}</td>
+                                <td className="td-mono">{k.prefix}</td>
+                                <td>{new Date(k.created_at * 1000).toLocaleDateString()}</td>
+                                <td>{k.last_used ? timeAgo(k.last_used) + ' назад' : 'никогда'}</td>
+                                <td className="td-actions">
+                                    <div className="actions">
+                                        <button
+                                            className="btn-icon btn-icon--danger"
+                                            title="Удалить ключ"
+                                            onClick={() => deleteKey(k.id, k.label)}
+                                        ><IcoTrash /></button>
+                                    </div>
+                                </td>
+                            </tr>
+                        ))}
+                    </tbody>
+                </table>
+            </div>
+
+            {/* Мобильный вид: таблица скрыта (.table-card), ключи — карточками */}
+            <div className="apikey-cards-list">
+                <p className="apikey-count">{keys.length} ключей</p>
+                {keys.length === 0 ? (
+                    <p className="apikey-empty">Нет ключей</p>
+                ) : keys.map((k, i) => (
+                    <div className="apikey-card" key={k.id}>
+                        <div className="apikey-card-header">
+                            <div className="apikey-card-title">
+                                <span className="apikey-card-num">#{i + 1}</span>
+                                <span className="apikey-card-label">{k.label}</span>
+                            </div>
+                            <button
+                                className="btn btn--danger btn--sq"
+                                aria-label="Удалить ключ"
+                                onClick={() => deleteKey(k.id, k.label)}
+                            ><IcoTrash /></button>
+                        </div>
+                        <code className="apikey-card-prefix">{k.prefix}</code>
+                        <div className="apikey-card-meta">
+                            <span>Создан {new Date(k.created_at * 1000).toLocaleDateString()}</span>
+                            <span>{k.last_used ? timeAgo(k.last_used) + ' назад' : 'не использован'}</span>
+                        </div>
+                    </div>
+                ))}
+            </div>
+
+            {created && (
+                <div className="qr-backdrop" onClick={() => setCreated(null)}>
+                    <div className="qr-card" onClick={e => e.stopPropagation()}>
+                        <p className="qr-name">Ключ «{created.label}» создан</p>
+                        <p className="qr-hint">
+                            Скопируй ключ сейчас — он показывается один раз и больше не будет доступен.
+                        </p>
+                        <code className="apikey-value">{created.key}</code>
+                        <div className="qr-actions">
+                            <button className="btn btn--primary" onClick={async () => {
+                                await copyText(created.key);
+                                showMsg('Ключ скопирован');
+                            }}><IcoCopy /> Скопировать</button>
+                            <button className="btn btn--tonal" onClick={() => setCreated(null)}>Закрыть</button>
+                        </div>
+                    </div>
+                </div>
+            )}
+        </>
+    );
+}
@@ -0,0 +1,6 @@
+{
+  "id": "apikeys",
+  "label": "API-ключи",
+  "icon": "key",
+  "order": 2
+}
@@ -0,0 +1,370 @@
+// 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 { Fragment, useState, useEffect, useCallback } from 'react';
+import QRCode from 'qrcode';
+import { apiFetch, copyText, bytes, timeAgo, genLabel, type NodeInfo, type PageProps } from '../../lib/shared';
+import { IcoPlus, IcoTrash, IcoCopy, IcoQR, IcoKey, IcoRefresh, IcoSettings } from '../../components/icons';
+import './masterkeys.css';
+
+// Вкладка «Мастер-ключи»: sen://-подписки для SenAWG. Мастер-ключ — это ссылка
+// плюс лимит устройств; устройства регистрируются сами (приватный ключ остаётся
+// на них) и здесь только отображаются и отзываются. Формат — docs/sen-link.md.
+interface MasterKey { id: number; label: string; device_limit: number; devices: number; servers: number[]; created_at: 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;
+    servers_total: number; servers_ok: number;   // на скольких серверах ключа уже стоит его текущий ключ
+}
+
+// Устройство ещё не на всех серверах ключа (нода не в сети при регистрации или смене ключа) —
+// панель догонит, когда нода появится.
+const syncLabel = (d: Device): string =>
+    d.servers_ok < d.servers_total ? ` · на ${d.servers_ok} из ${d.servers_total} серверов` : '';
+
+// Платформа и версия клиента: «macOS-0.6.5»; без версии — просто платформа.
+const platformLabel = (d: Device): string =>
+    d.platform ? (d.version ? `${d.platform}-${d.version}` : d.platform) : '—';
+
+const errText = (e: any): string => e?.response?.data?.error ?? 'Ошибка запроса';
+
+export default function MasterKeysPage({ token, showMsg }: PageProps) {
+    const [keys, setKeys]       = useState<MasterKey[]>([]);
+    const [enabled, setEnabled] = useState(true);
+    const [tls, setTls]         = useState(false);
+    const [nodes, setNodes]     = useState<NodeInfo[]>([]);   // серверы, которые можно включить в ключ
+    const [label, setLabel]     = useState('');
+    const [limit, setLimit]     = useState('3');
+    const [devs, setDevs]       = useState<Record<number, Device[]>>({});
+    const [folded, setFolded]   = useState<Set<number>>(new Set());   // свёрнутые узлы
+    const [tools, setTools]     = useState<number | null>(null);        // узел с открытыми настройками
+    const [limitEdit, setLimitEdit] = useState('');
+    const [modal, setModal]     = useState<{ label: string; link: string; tls: boolean; dataUrl: string } | null>(null);
+
+    const load = useCallback(async () => {
+        try {
+            const d = await apiFetch('GET', '/ui/masterkeys', token);
+            const list: MasterKey[] = d.keys ?? [];
+            setKeys(list); setEnabled(!!d.enabled); setTls(!!d.tls);
+            apiFetch('GET', '/ui/nodes', token).then(r => setNodes(r.nodes ?? [])).catch(() => {});
+            const all = await Promise.all(list.map(k =>
+                apiFetch('GET', `/ui/masterkeys/${k.id}/devices`, token).then(r => [k.id, r.devices ?? []] as const)));
+            setDevs(Object.fromEntries(all));
+        } catch { showMsg('Ошибка загрузки мастер-ключей'); }
+    }, [token, showMsg]);
+
+    // Действие над ключом/устройством: выполнить, показать сообщение, обновить данные.
+    const act = useCallback(async (fn: () => Promise<unknown>, ok: string) => {
+        try { await fn(); showMsg(ok); await load(); }
+        catch (e) { showMsg(errText(e)); }
+    }, [load, showMsg]);
+
+    const create = useCallback(async () => {
+        if (!label.trim()) return;
+        await act(async () => {
+            // Новый ключ отдаёт все серверы, которые уже подключались; набор потом правится в настройках ключа.
+            const ready = nodes.filter(n => !n.pending).map(n => n.id);
+            await apiFetch('POST', '/ui/masterkeys', token, {
+                label: label.trim(), device_limit: Number(limit), ...(ready.length ? { servers: ready } : {}),
+            });
+            setLabel('');
+        }, 'Мастер-ключ создан');
+    }, [label, limit, nodes, token, act]);
+
+    const remove = useCallback(async (k: MasterKey) => {
+        if (!confirm(`Удалить «${k.label}»? Все ${k.devices} устройств потеряют доступ.`)) return;
+        await act(() => apiFetch('DELETE', `/ui/masterkeys/${k.id}`, token), 'Удалён: ' + k.label);
+    }, [token, act]);
+
+    const fetchLink = useCallback(async (k: MasterKey) => {
+        const r = await apiFetch('GET', `/ui/masterkeys/${k.id}/link`, token);
+        return r as { link: string; tls: boolean };
+    }, [token]);
+
+    const showQR = useCallback(async (k: MasterKey) => {
+        try {
+            const { link, tls: t } = await fetchLink(k);
+            const dataUrl = await QRCode.toDataURL(link, { width: 560, margin: 2, errorCorrectionLevel: 'H' });
+            setModal({ label: k.label, link, tls: t, dataUrl });
+        } catch (e) { showMsg(errText(e)); }
+    }, [fetchLink, showMsg]);
+
+    const copyLink = useCallback(async (k: MasterKey) => {
+        try { await copyText((await fetchLink(k)).link); showMsg('Ссылка скопирована'); }
+        catch (e) { showMsg(errText(e)); }
+    }, [fetchLink, showMsg]);
+
+    const fold = (id: number) => setFolded(prev => {
+        const n = new Set(prev); n.has(id) ? n.delete(id) : n.add(id); return n;
+    });
+    const openTools = (k: MasterKey) => { setLimitEdit(String(k.device_limit)); setTools(tools === k.id ? null : k.id); };
+
+    useEffect(() => { if (token) load(); }, [token, load]);
+
+    const actions = (k: MasterKey) => (
+        <div className="actions">
+            <button className="btn-icon" title="QR-код" aria-label="QR-код" onClick={() => showQR(k)}><IcoQR /></button>
+            <button className="btn-icon" title="Скопировать ссылку" aria-label="Скопировать ссылку" onClick={() => copyLink(k)}><IcoCopy /></button>
+            <button className="btn-icon" title="Настройки мастер-ключа" aria-label="Настройки мастер-ключа" aria-expanded={tools === k.id} onClick={() => openTools(k)}><IcoSettings /></button>
+            <button className="btn-icon btn-icon--danger" title="Удалить мастер-ключ" aria-label="Удалить мастер-ключ" onClick={() => remove(k)}><IcoTrash /></button>
+        </div>
+    );
+
+    const toolbox = (k: MasterKey) => (
+        <div className="mk-tools">
+            {/* Слева — настройки самого ключа */}
+            <section className="mk-box">
+                <h4 className="mk-box-title">Настройки ключа</h4>
+                <div className="mk-setting">
+                    <div className="mk-setting-text">
+                        <label className="mk-setting-name" htmlFor={`mk-limit-${k.id}`}>Лимит устройств</label>
+                        <span className="mk-setting-hint">Сколько устройств может подключить ключ</span>
+                    </div>
+                    <div className="mk-setting-ctl">
+                        <input id={`mk-limit-${k.id}`} className="field mk-limit-input" type="number" min={1} max={100}
+                            value={limitEdit} onChange={e => setLimitEdit(e.target.value)} />
+                        <button className="btn btn--tonal" onClick={() =>
+                            act(() => apiFetch('PATCH', `/ui/masterkeys/${k.id}`, token, { device_limit: Number(limitEdit) }), 'Лимит сохранён')}>
+                            Сохранить
+                        </button>
+                    </div>
+                </div>
+                <div className="mk-setting">
+                    <div className="mk-setting-text">
+                        <span className="mk-setting-name">Ссылка</span>
+                        <span className="mk-setting-hint">Старая перестанет принимать новые устройства</span>
+                    </div>
+                    <div className="mk-setting-ctl">
+                        <button className="btn btn--tonal" onClick={() => {
+                            if (confirm('Выпустить новую ссылку? Старая перестанет принимать новые устройства, уже добавленные продолжат работать.'))
+                                act(() => apiFetch('POST', `/ui/masterkeys/${k.id}/rotate`, token), 'Ссылка перевыпущена');
+                        }}>Перевыпустить</button>
+                    </div>
+                </div>
+                <div className="mk-setting">
+                    <div className="mk-setting-text">
+                        <span className="mk-setting-name">Ключи устройств</span>
+                        <span className="mk-setting-hint">Клиенты сменят их при следующем опросе</span>
+                    </div>
+                    <div className="mk-setting-ctl">
+                        <button className="btn btn--tonal" onClick={() =>
+                            act(() => apiFetch('POST', `/ui/masterkeys/${k.id}/rekey`, token), 'Смена ключей запрошена')}>
+                            Запросить смену
+                        </button>
+                    </div>
+                </div>
+            </section>
+
+            {/* Справа — какие серверы отдаёт ключ: в config.servers[] каждого устройства. Снять галочку —
+                пиры его устройств с этого сервера удалятся; поставить — добавятся. Последний не снимается. */}
+            <section className="mk-box">
+                <h4 className="mk-box-title">Серверы ключа</h4>
+                {nodes.map(n => {
+                    const on = k.servers.includes(n.id);
+                    const last = on && k.servers.length === 1;
+                    const h = n.health;
+                    return (
+                        <label className={`mk-server${last ? ' mk-server--locked' : ''}`} key={n.id}>
+                            <input type="checkbox" checked={on} disabled={last}
+                                onChange={() => {
+                                    const next = on ? k.servers.filter(id => id !== n.id) : [...k.servers, n.id];
+                                    act(() => apiFetch('PATCH', `/ui/masterkeys/${k.id}`, token, { servers: next }),
+                                        on ? `«${h?.server || n.name}» убран из ключа` : `«${h?.server || n.name}» добавлен в ключ`);
+                                }} />
+                            <span className={`chip chip--${n.online ? 'online' : 'offline'} mk-server-dot`} title={n.online ? 'В сети' : 'Нет связи'}>
+                                <span className="chip-dot" />
+                            </span>
+                            <span className="mk-server-name">{h?.server || n.name}</span>
+                            {h?.ip && <code className="mk-server-ip">{h.ip}</code>}
+                            {h?.gen && <span className="mk-server-gen">{genLabel(h.gen)}</span>}
+                        </label>
+                    );
+                })}
+                <p className="mk-setting-hint">Новые серверы добавляются кнопкой «Добавить сервер» над вкладкой.</p>
+            </section>
+        </div>
+    );
+
+    // Полоска занятых слотов: числа по краям внутри; цвет по заполнению.
+    const meter = (k: MasterKey, n: number) => (
+        <div className={`mk-meter${n >= k.device_limit ? ' mk-meter--full' : n * 3 >= k.device_limit * 2 ? ' mk-meter--warn' : ''}`}
+            role="progressbar" aria-label="Устройства" aria-valuemin={0}
+            aria-valuemax={k.device_limit} aria-valuenow={n}
+            title={`Устройств: ${n} из ${k.device_limit}`}>
+            <span className="mk-meter-text"><span>{n}</span><span>{k.device_limit}</span></span>
+            <div className="mk-meter-fill"
+                style={{ width: `${Math.min(100, (n / Math.max(1, k.device_limit)) * 100)}%` }}>
+                {/* тот же текст поверх заливки — светлый, чтобы читался на ней */}
+                <span className="mk-meter-text mk-meter-text--on" aria-hidden="true"><span>{n}</span><span>{k.device_limit}</span></span>
+            </div>
+        </div>
+    );
+
+    const deviceActions = (d: Device) => (
+        <div className="actions">
+            <button className="btn-icon" title="Новый PSK" aria-label="Новый PSK" onClick={async () => {
+                try {
+                    const r = await apiFetch('POST', `/ui/devices/${d.id}/psk`, token);
+                    showMsg(r.pending ? `PSK обновлён; ещё на ${r.pending} — когда сервер будет на связи` : 'PSK обновлён');
+                    await load();
+                } catch (e) { showMsg(errText(e)); }
+            }}><IcoRefresh /></button>
+            <button className="btn-icon btn-icon--danger" title="Отозвать устройство" aria-label="Отозвать устройство" onClick={() => {
+                if (confirm('Отозвать устройство «' + (d.device_name || d.id) + '»?'))
+                    act(() => apiFetch('DELETE', `/ui/devices/${d.id}`, token), 'Устройство отозвано');
+            }}><IcoTrash /></button>
+        </div>
+    );
+
+    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)}
+            onClick={() => fold(k.id)}>▾</button>
+    );
+
+    const deviceNode = (k: MasterKey, d: Device) => (
+        <li className="mk-node mk-node--device" key={d.id}>
+            <div className="mk-device">
+                <div className="mk-device-main">
+                    <span className="mk-device-title">
+                        <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) + ' назад' : 'никогда'}
+                        {d.rekey_requested ? ' · ждёт смены ключа' : ''}{syncLabel(d)}</span>
+                </div>
+                <span className={`chip chip--${d.online ? 'online' : 'offline'}`}>
+                    <span className="chip-dot" />{d.online ? 'Онлайн' : 'Офлайн'}
+                </span>
+                <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>
+                </div>
+                {deviceActions(d)}
+            </div>
+        </li>
+    );
+
+    return (
+        <>
+            {!enabled && (
+                <p className="mk-notice">Подписка не настроена на сервере: нет ключа подписи или SUB_PORT. Ссылки выдавать нельзя.</p>
+            )}
+            {enabled && !tls && (
+                <p className="mk-notice">Подписка работает без TLS: ответы подписаны, но secret ссылки и конфиг видны в сети.</p>
+            )}
+
+            <div className="toolbar">
+                <input className="field" placeholder="Метка (напр. Семья)" value={label}
+                    onChange={e => setLabel(e.target.value)} onKeyDown={e => e.key === 'Enter' && create()} />
+                <input className="field mk-limit-input" type="number" min={1} max={100} title="Лимит устройств"
+                    aria-label="Лимит устройств" value={limit} onChange={e => setLimit(e.target.value)} />
+                <div className="toolbar-btns">
+                    <button className="btn btn--primary" onClick={create}><IcoPlus /> Создать ключ</button>
+                </div>
+            </div>
+
+            {/* Десктоп: таблица, иерархия — строка мастер-ключа и устройства под ней */}
+            <div className="table-card mk-table-card">
+                <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>
+                        </tr>
+                    </thead>
+                    <tbody>
+                        {keys.length === 0 ? (
+                            <tr><td colSpan={9} className="empty">Нет мастер-ключей</td></tr>
+                        ) : keys.map(k => {
+                            const list = devs[k.id] ?? [];
+                            const free = Math.max(0, k.device_limit - list.length);
+                            const open = !folded.has(k.id);
+                            return (
+                                <Fragment key={k.id}>
+                                    <tr className="mk-tr-master">
+                                        <td><span className="mk-name">{caret(k)}<IcoKey />{k.label}</span></td>
+                                        <td colSpan={6}></td>
+                                        <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>
+                                            </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>
+                                            <td></td>
+                                            <td className="td-actions mk-td-actions">{deviceActions(d)}</td>
+                                        </tr>
+                                    ))}
+                                    {open && free > 0 && (
+                                        <tr className="mk-tr-free mk-last">
+                                            <td colSpan={9}><span className="mk-indent">Свободно: {free}</span></td>
+                                        </tr>
+                                    )}
+                                </Fragment>
+                            );
+                        })}
+                    </tbody>
+                </table>
+            </div>
+
+            {/* Мобильный: таблица скрыта (.table-card), то же — деревом карточек */}
+            {keys.length === 0 ? <p className="mk-empty mk-tree">Нет мастер-ключей</p> : (
+                <ul className="mk-tree">
+                    {keys.map(k => {
+                        const list = devs[k.id] ?? [];
+                        const free = Math.max(0, k.device_limit - list.length);
+                        const isFolded = folded.has(k.id);
+                        return (
+                            <li className="mk-root" key={k.id}>
+                                <div className="mk-master">
+                                    {caret(k)}
+                                    <IcoKey />
+                                    <span className="mk-master-label">{k.label}</span>
+                                    {meter(k, list.length)}
+                                    {actions(k)}
+                                </div>
+                                {tools === k.id && toolbox(k)}
+                                {!isFolded && (
+                                    <ul className="mk-children">
+                                        {list.map(d => deviceNode(k, d))}
+                                        {free > 0 && (
+                                            <li className="mk-node mk-node--free"><div className="mk-free">Свободно: {free}</div></li>
+                                        )}
+                                    </ul>
+                                )}
+                            </li>
+                        );
+                    })}
+                </ul>
+            )}
+
+            {modal && (
+                <div className="qr-backdrop" onClick={() => setModal(null)}>
+                    <div className="qr-card" onClick={e => e.stopPropagation()}>
+                        <p className="qr-name">{modal.label}</p>
+                        <img className="qr-img" src={modal.dataUrl} alt="QR" title="Нажми чтобы скопировать sen:// ссылку"
+                            onClick={async () => { await copyText(modal.link); showMsg('Ссылка скопирована'); }} />
+                        <p className="qr-hint">Отсканируй в SenAWG · нажми на QR чтобы скопировать{modal.tls ? '' : ' · без TLS'}</p>
+                        <div className="qr-actions">
+                            <button className="btn btn--primary" onClick={async () => { await copyText(modal.link); showMsg('Ссылка скопирована'); }}><IcoCopy /> Скопировать</button>
+                            <button className="btn btn--tonal" onClick={() => setModal(null)}>Закрыть</button>
+                        </div>
+                    </div>
+                </div>
+            )}
+        </>
+    );
+}
@@ -0,0 +1,279 @@
+/*
+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. */
+
+.mk-notice {
+    font-size: 13px;
+    color: var(--error-text);
+    background: var(--error-bg);
+    border-radius: 16px;
+    padding: 10px 16px;
+}
+.mk-empty { font-size: 14px; color: var(--neutral-text); text-align: center; padding: 48px 0; }
+.mk-limit-input { width: 88px !important; }
+
+/* ── таблица (десктоп) ── */
+.mk-table td, .mk-table th { white-space: nowrap; }
+.mk-table .td-actions { width: 150px; }
+.mk-table .mk-device-id { display: inline-block; max-width: 170px; vertical-align: middle; }
+.mk-table th, .mk-table td { padding-left: 10px; padding-right: 10px; }
+.mk-table th:first-child, .mk-table td:first-child { padding-left: 20px; }
+.mk-table th:last-child, .mk-table td:last-child { padding-right: 16px; }
+.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); }
+.mk-name .mk-caret { margin-left: -8px; }
+.mk-tr-master .mk-name { color: var(--on-surface); }
+.mk-tr-master .mk-name svg { color: var(--primary); }
+.mk-tr-tools td { background: var(--surface-container); padding-top: 4px; padding-bottom: 12px; }  /* слева/справа — общие отступы колонок таблицы: блок стоит под заголовком «Имя» */
+.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-tr-device td:first-child, .mk-tr-free td:first-child {
+    background: linear-gradient(var(--outline), var(--outline)) 30px 0 / 2px 100% no-repeat;
+}
+.mk-tr-device.mk-last td:first-child, .mk-tr-free.mk-last td:first-child { background-size: 2px 50%; }
+.mk-indent { position: relative; display: inline-block; padding-left: 36px; }
+.mk-indent::before {
+    content: ''; position: absolute; left: 10px; top: 50%; width: 16px;
+    border-top: 2px solid var(--outline);
+}
+.mk-tr-free td { color: var(--neutral-dot); font-size: 12px; }
+.mk-tr-free:hover { background: transparent; }
+
+/* ── дерево (мобильный) ── */
+.mk-tree, .mk-children { list-style: none; margin: 0; padding: 0; }
+.mk-tree { display: none; flex-direction: column; gap: 12px; }  /* только мобильный */
+
+.mk-root {
+    background: var(--surface-bright);
+    border: 1px solid var(--outline-variant);
+    border-radius: var(--r-card);
+    padding: 12px 18px 14px;
+}
+
+/* родитель */
+.mk-master { display: flex; align-items: center; gap: 10px; color: var(--primary); min-height: 42px; }
+.mk-master-label {
+    font-size: 16px;
+    font-weight: 500;
+    color: var(--on-surface);
+    flex: 1;
+    min-width: 0;
+    overflow: hidden;
+    text-overflow: ellipsis;
+    white-space: nowrap;
+}
+.mk-caret {
+    width: 28px; height: 28px;
+    border: 0; border-radius: 50%;
+    background: transparent;
+    color: var(--neutral-text);
+    font-size: 16px;
+    cursor: pointer;
+    flex-shrink: 0;
+    transition: transform 0.15s;
+}
+.mk-caret:hover { background: var(--state-neutral); }
+.mk-caret--folded { transform: rotate(-90deg); }
+
+.mk-tools {
+    display: grid;
+    grid-template-columns: minmax(0, 1fr) minmax(0, 1fr);
+    gap: 12px;
+    align-items: stretch;
+    margin: 6px 0 8px;
+}
+/* два одинаковых блока: слева настройки ключа, справа серверы */
+.mk-box {
+    display: flex; flex-direction: column; gap: 10px;
+    background: var(--surface-bright);
+    border: 1px solid var(--outline-variant);
+    border-radius: 16px;
+    padding: 12px 16px 14px;
+}
+.mk-box-title { margin: 0; font-size: 13px; font-weight: 500; color: var(--label); }
+.mk-box .mk-box-title { margin-bottom: 2px; }
+/* строка настройки: слева название и пояснение, справа контрол */
+.mk-setting {
+    display: flex; align-items: center; justify-content: space-between; gap: 16px;
+    padding: 10px 0;
+    border-top: 1px solid var(--outline-variant);
+}
+.mk-box-title + .mk-setting { border-top: 0; padding-top: 4px; }
+.mk-setting:last-child { padding-bottom: 0; }
+.mk-setting-text { display: flex; flex-direction: column; gap: 2px; min-width: 0; }
+.mk-setting-name { font-size: 14px; font-weight: 500; color: var(--on-surface); }
+.mk-setting-hint { font-size: 12px; color: var(--neutral-text); }
+.mk-setting-ctl { display: flex; align-items: center; gap: 8px; flex-shrink: 0; }
+.mk-setting-ctl .btn { height: 36px; padding: 0 16px; font-size: 13px; }
+.mk-limit-input { height: 36px; width: 80px !important; text-align: center; }
+
+/* прогресс занятых слотов с числом внутри; полный — цветом «ошибка».
+   Текст дублируется: тёмный на дорожке, светлый поверх заливки (обрезается ею). */
+.mk-meter {
+    --mk-w: 136px;
+    --meter-fill: var(--success-dot);   /* < 2/3 — зелёный */
+    --meter-on: #2a2118;                /* цвет числа поверх заливки */
+    position: relative;
+    width: var(--mk-w); height: 20px;
+    border-radius: var(--r-pill);
+    background: var(--outline-variant);
+    overflow: hidden;
+    flex-shrink: 0;
+}
+.mk-meter-fill {
+    position: absolute; left: 0; top: 0; bottom: 0;
+    background: var(--meter-fill);
+    overflow: hidden;
+    transition: width 0.25s, background 0.25s;
+}
+/* числа по краям внутри полоски: текущее слева, лимит справа */
+.mk-meter-text {
+    position: absolute; left: 0; top: 0;
+    width: var(--mk-w); height: 100%;
+    box-sizing: border-box;
+    padding: 0 11px;
+    display: flex; align-items: center; justify-content: space-between;
+    font-size: 12px; font-weight: 500;
+    font-variant-numeric: tabular-nums;
+    color: var(--on-surface);
+}
+.mk-meter-text--on { color: var(--meter-on); }
+.mk-meter--warn { --meter-fill: var(--warn-dot); }                 /* от 2/3 — оранжевый */
+.mk-meter--full { --meter-fill: var(--error-dot); --meter-on: #fff; } /* лимит — красный */
+:root[data-theme="dark"] .mk-meter--full { --meter-on: #2a2118; }
+
+/* серверы, отдаваемые по ключу (заглушка) */
+.mk-server {
+    display: flex; align-items: center; gap: 10px;
+    background: var(--surface-container);
+    border-radius: 12px;
+    padding: 10px 14px;
+    font-size: 13px;
+    color: var(--on-surface);
+}
+.mk-server input { accent-color: var(--primary); margin: 0; }
+.mk-server-name { font-weight: 500; }
+.mk-server-ip, .mk-server-gen { font-size: 12px; color: var(--neutral-text); }
+.mk-server-ip { font-family: var(--mono); margin-left: auto; }
+.mk-server { cursor: pointer; }
+.mk-server:hover { background: var(--state-primary); }
+.mk-server--locked { cursor: default; }
+.mk-server--locked:hover { background: var(--surface-container); }
+.mk-server-dot { padding: 0; background: none; }
+.mk-box .tip-wrap { width: 100%; }
+
+/* дети: вертикальная линия слева и «ножка» к каждому узлу */
+.mk-children { margin: 8px 0 0 18px; padding-left: 28px; border-left: 2px solid var(--outline); }
+.mk-node { position: relative; padding: 4px 0; }
+.mk-node::before {
+    content: '';
+    position: absolute;
+    left: -28px; top: 50%;
+    width: 28px;
+    border-top: 2px solid var(--outline);
+}
+/* последний узел: линия родителя обрывается на его «ножке» */
+.mk-node:last-child::after {
+    content: '';
+    position: absolute;
+    left: -30px; top: calc(50% + 1px); bottom: 0;
+    width: 2px;
+    background: var(--surface-bright);
+}
+
+.mk-device {
+    display: flex; align-items: center; gap: 12px; flex-wrap: wrap;
+    background: var(--surface-container);
+    border-radius: 14px;
+    padding: 8px 14px;
+}
+.mk-device-main { display: flex; flex-direction: column; min-width: 0; flex: 1 1 160px; }
+.mk-device-title { display: flex; align-items: baseline; gap: 8px; min-width: 0; }
+.mk-device-id {
+    font-family: var(--mono);
+    font-size: 11px;
+    color: var(--neutral-text);
+    background: var(--surface-bright);
+    border-radius: var(--r-pill);
+    padding: 1px 8px;
+    min-width: 0;
+    max-width: 200px;
+    overflow: hidden;
+    text-overflow: ellipsis;
+    white-space: nowrap;
+}
+.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-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; }
+
+.mk-free {
+    border: 1px dashed var(--outline);
+    border-radius: 14px;
+    padding: 10px 14px;
+    font-size: 13px;
+    color: var(--neutral-dot);
+}
+
+/* ── мобильный (design.md, часть IV): одна колонка, тач-цели ≥ 44px, rx/tx блоками
+      50/50, действия рядом с большим пальцем ── */
+@media (max-width: 640px) {
+    .mk-tree { display: flex; }
+    .mk-limit-input { width: 100% !important; }
+
+    .mk-root { padding: 12px; }
+
+    /* родитель: шапка, затем ряд действий на всю ширину */
+    .mk-master { flex-wrap: wrap; row-gap: 10px; }
+    .mk-master .actions { width: 100%; gap: 8px; }
+    .mk-caret { width: 44px; height: 44px; margin: -6px 0 -6px -8px; }
+    .mk-meter { --mk-w: 112px; height: 24px; }
+
+    /* настройки узла: поля и кнопки на всю ширину */
+    .mk-tools { grid-template-columns: minmax(0, 1fr); margin: 8px 0 4px; }
+    .mk-setting { flex-direction: column; align-items: stretch; gap: 8px; }
+    .mk-setting-ctl { width: 100%; }
+    .mk-setting-ctl .btn { flex: 1; height: 44px; }
+    .mk-setting-ctl .mk-limit-input { width: 100% !important; flex: 1; height: 44px; }
+    .mk-tools .btn { width: 100%; height: 44px; justify-content: center; }
+
+    /* дерево уже: отступы поменьше, «ножки» короче */
+    .mk-children { margin-left: 8px; padding-left: 14px; }
+    .mk-node { padding: 4px 0; }
+    .mk-node::before { left: -14px; width: 14px; }
+    .mk-node:last-child::after { left: -16px; }
+
+    /* устройство — карточка: заголовок + чип, метрики 50/50, ряд действий */
+    .mk-device { border-radius: 16px; padding: 12px; gap: 10px; }
+    .mk-device-main { flex: 1 1 0; }
+    .mk-device-title { flex-wrap: wrap; row-gap: 2px; }
+    .mk-device-id { max-width: 100%; }
+    .mk-device-traffic { width: 100%; gap: 8px; }
+    .mk-metric {
+        flex: 1; flex-direction: column; gap: 2px;
+        background: var(--surface-bright);
+        border-radius: 16px; padding: 8px 12px;
+    }
+    .mk-metric i { font-family: var(--font, inherit); font-size: 12px; color: var(--neutral-text); }
+    .mk-metric-name::after { content: attr(data-sfx); }
+    .mk-metric b { font-size: 16px; font-weight: 500; color: var(--on-surface); }
+
+    /* кнопки действий: контурные, на всю ширину ряда, 44px */
+    .mk-device .actions { width: 100%; gap: 8px; }
+    .mk-master .btn-icon, .mk-device .btn-icon {
+        flex: 1; width: auto; height: 44px;
+        border: 1px solid var(--outline);
+        border-radius: var(--r-pill);
+    }
+    .mk-master .btn-icon--danger, .mk-device .btn-icon--danger { border-color: var(--error-dot); }
+
+    .mk-free { padding: 12px; font-size: 13px; }
+}
@@ -0,0 +1,6 @@
+{
+  "id": "masterkeys",
+  "label": "Мастер-ключи",
+  "icon": "key",
+  "order": 1.5
+}
@@ -0,0 +1,753 @@
+// 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.
+//
+// sen://-подписка: реестр мастер-ключей/устройств (ui.db), админ-роуты панели
+// (/ui/masterkeys, /ui/devices, за JWT) и публичный листенер /sub/v1/* на
+// отдельном порту SUB_PORT. Протокол и формат ссылки — docs/sen-link.md.
+//
+// awg-ctrl про мастер-ключи ничего не знает: сюда он отдаёт только пиров по
+// публичному ключу (/api/peers*) и общий профиль сервера (/api/profile).
+//
+// Несколько серверов. Мастер-ключ отдаёт набор серверов (master_servers): локальный
+// awg-ctrl (id 0) и/или ноды. Устройство регистрирует один ключ WireGuard, и он
+// становится пиром на каждом сервере набора — IP и PSK на каждом свои (device_peers).
+// Нода может быть не в сети, поэтому изменения не «толкаются», а сводятся: device_peers
+// хранит, какой ключ сейчас стоит на сервере, peer_tombstones — что там надо удалить,
+// а reconcile() приводит сервер к нужному состоянию, как только до него можно достучаться
+// (сразу при действии, при подключении ноды и раз в минуту).
+import crypto from "crypto";
+import fs from "fs";
+import http from "http";
+import https from "https";
+import path from "path";
+import express, { Request, Response, NextFunction, Router } from "express";
+import type Database from "better-sqlite3";
+import {
+    encodeSenLink, rawPublicKey, publicKeyFromRaw, spkiPin,
+    signResponse, verifyRequest,
+} from "./sen";
+
+type Ctrl = (method: string, urlPath: string, body?: unknown) => Promise<{ status: number; data: any }>;
+
+/** Что подписке нужно от реестра серверов (awg-ui/nodes.ts). */
+export interface Servers {
+    ctrlFor(id: number): Ctrl;
+    exists(id: number): boolean;
+    isOnline(id: number): boolean;
+    ids(): number[];
+    defaultId(): number;
+    onOnline(cb: (id: number) => void): void;
+}
+
+interface MasterRow {
+    id: number; label: string; secret: Buffer; device_limit: number;
+    server_id: number; created_at: number; revoked_at: number | null;
+}
+interface DeviceRow {
+    id: number; master_id: number; device_id: string; device_name: string; platform: string;
+    pub_key: string; auth_pub: string; created_at: number; last_seen: number | null;
+    rekey_requested: number; version: string;
+}
+interface LinkRow {
+    device_id: number; server_id: number; peer_pub: string | null;
+    ip: string | null; psk: string | null; psk_pending: number;
+}
+interface Profile {
+    name: string; endpoint: string; server_pub: string; gen: string;
+    dns: string[]; keepalive: string; mtu: number; awg: Record<string, string>;
+}
+
+const TS_WINDOW    = 300;           // секунд, ±
+const DEFAULT_LIMIT = 3;
+const MAX_SERVERS   = 32;           // серверов в одном мастер-ключе
+const SYNC_EVERY    = 60_000;       // фоновое сведение серверов
+const B64_PUB       = /^[A-Za-z0-9+/]{43}=$/;
+const CLIENT_VERSION = /^[\w.+-]{1,32}$/;   // версия приложения, чисто информационная
+
+// pub_key WireGuard в пути к awg-ctrl — base64url (в обычном base64 есть «/»).
+const pubParam = (pub: string) => Buffer.from(pub, "base64").toString("base64url");
+
+// ── Простой лимитер по IP ──────────────────────────────────────────────────
+function makeLimiter(max: number, windowMs: number) {
+    const hits = new Map<string, { n: number; reset: number }>();
+    return (ip: string): boolean => {
+        const now = Date.now();
+        const e = hits.get(ip);
+        if (!e || e.reset < now) { hits.set(ip, { n: 1, reset: now + windowMs }); return true; }
+        if (e.n >= max) return false;
+        e.n++;
+        return true;
+    };
+}
+
+export function createSub(deps: { uidb: Database.Database; servers: Servers; baseDir: string }) {
+    const { uidb, servers } = deps;
+
+    // ── Настройка из окружения ─────────────────────────────────────────────
+    const SUB_PORT = Number(process.env.SUB_PORT) || 0;
+    const SUB_TLS  = (process.env.SUB_TLS ?? "off").toLowerCase() === "on";
+    // Публичный адрес панели для ссылок и endpoints. Без него — адрес локального сервера,
+    // а у панели без своего VPN — тот, по которому к ней пришли.
+    const SUB_HOST = (process.env.SUB_HOST ?? "").trim();
+    const file = (env: string | undefined, name: string) => env || path.join(deps.baseDir, name);
+
+    let signKey: crypto.KeyObject | null = null;
+    let signPub: Buffer | null = null;
+    try {
+        signKey = crypto.createPrivateKey(fs.readFileSync(file(process.env.SUB_SIGN_KEY_FILE, "sub_sign.key")));
+        signPub = rawPublicKey(crypto.createPublicKey(signKey));
+    } catch {
+        console.warn("sub: ключ подписи не найден — sen://-подписка отключена");
+    }
+
+    let tlsMaterial: { key: Buffer; cert: Buffer } | null = null;
+    let tlsPin: Buffer | null = null;
+    if (SUB_TLS) {
+        try {
+            tlsMaterial = {
+                key:  fs.readFileSync(file(process.env.SUB_TLS_KEY_FILE,  "sub_tls.key")),
+                cert: fs.readFileSync(file(process.env.SUB_TLS_CERT_FILE, "sub_tls.crt")),
+            };
+            tlsPin = spkiPin(tlsMaterial.cert.toString());
+        } catch {
+            console.warn("sub: SUB_TLS=on, но сертификат не найден — подписка отключена");
+            signKey = null;
+        }
+    }
+
+    // ── Схема ──────────────────────────────────────────────────────────────
+    uidb.exec(`
+        CREATE TABLE IF NOT EXISTS master_keys (
+            id           INTEGER PRIMARY KEY AUTOINCREMENT,
+            label        TEXT    NOT NULL,
+            secret       BLOB    NOT NULL UNIQUE,
+            device_limit INTEGER NOT NULL DEFAULT ${DEFAULT_LIMIT},
+            server_id    INTEGER NOT NULL DEFAULT 0,
+            created_at   INTEGER NOT NULL,
+            revoked_at   INTEGER
+        );
+        CREATE TABLE IF NOT EXISTS devices (
+            id              INTEGER PRIMARY KEY AUTOINCREMENT,
+            master_id       INTEGER NOT NULL REFERENCES master_keys(id) ON DELETE CASCADE,
+            device_id       TEXT    NOT NULL,
+            device_name     TEXT    NOT NULL DEFAULT '',
+            platform        TEXT    NOT NULL DEFAULT '',
+            pub_key         TEXT    NOT NULL UNIQUE,
+            auth_pub        TEXT    NOT NULL UNIQUE,
+            created_at      INTEGER NOT NULL,
+            last_seen       INTEGER,
+            rekey_requested INTEGER NOT NULL DEFAULT 0,
+            UNIQUE (master_id, device_id)
+        );
+        -- Серверы мастер-ключа. master_keys.server_id остался от времени одного сервера и
+        -- дальше не читается (кроме переноса ниже).
+        CREATE TABLE IF NOT EXISTS master_servers (
+            master_id INTEGER NOT NULL REFERENCES master_keys(id) ON DELETE CASCADE,
+            server_id INTEGER NOT NULL,
+            PRIMARY KEY (master_id, server_id)
+        );
+        -- Пир устройства на сервере. peer_pub — ключ, который сейчас стоит на сервере
+        -- (NULL — ещё не добавлен); расходится с devices.pub_key после смены ключа, пока
+        -- сервер не догнали. ip/psk — как их выдал awg-ctrl этого сервера.
+        CREATE TABLE IF NOT EXISTS device_peers (
+            device_id   INTEGER NOT NULL REFERENCES devices(id) ON DELETE CASCADE,
+            server_id   INTEGER NOT NULL,
+            peer_pub    TEXT,
+            ip          TEXT,
+            psk         TEXT,
+            psk_pending INTEGER NOT NULL DEFAULT 0,
+            PRIMARY KEY (device_id, server_id)
+        );
+        -- Пиры, которые надо удалить с сервера, когда до него дотянемся.
+        CREATE TABLE IF NOT EXISTS peer_tombstones (
+            server_id INTEGER NOT NULL,
+            pub_key   TEXT    NOT NULL,
+            PRIMARY KEY (server_id, pub_key)
+        );
+        -- Последний известный профиль сервера: config собирается из него, даже когда
+        -- нода не в сети, — иначе сервер пропадал бы из подписки на время обрыва.
+        CREATE TABLE IF NOT EXISTS server_profiles (
+            server_id  INTEGER PRIMARY KEY,
+            profile    TEXT    NOT NULL,
+            updated_at INTEGER NOT NULL
+        );
+    `);
+    // Версия клиента — необязательное поле, добавленное позже: у уже созданной
+    // таблицы колонки может не быть.
+    if (!(uidb.prepare("PRAGMA table_info(devices)").all() as { name: string }[]).some(c => c.name === "version"))
+        uidb.exec("ALTER TABLE devices ADD COLUMN version TEXT NOT NULL DEFAULT ''");
+    uidb.pragma("foreign_keys = ON");
+
+    // Перенос со времени одного сервера: ключ отдавал master_keys.server_id, а пир устройства
+    // уже стоит там под devices.pub_key (ip/psk подтянет reconcile). У ключа всегда есть хотя
+    // бы один сервер, поэтому «ни одной строки» бывает только у ключей из старой схемы.
+    uidb.exec(`
+        INSERT OR IGNORE INTO master_servers (master_id, server_id)
+            SELECT id, server_id FROM master_keys
+            WHERE id NOT IN (SELECT master_id FROM master_servers);
+        INSERT OR IGNORE INTO device_peers (device_id, server_id, peer_pub)
+            SELECT d.id, m.server_id, d.pub_key FROM devices d JOIN master_keys m ON m.id = d.master_id
+            WHERE d.id NOT IN (SELECT device_id FROM device_peers);
+    `);
+
+    const q = {
+        masters:      uidb.prepare("SELECT m.*, (SELECT COUNT(*) FROM devices d WHERE d.master_id = m.id) AS devices FROM master_keys m WHERE revoked_at IS NULL ORDER BY id"),
+        masterById:   uidb.prepare<[number]>("SELECT * FROM master_keys WHERE id = ? AND revoked_at IS NULL"),
+        masterBySecret: uidb.prepare<[Buffer]>("SELECT * FROM master_keys WHERE secret = ? AND revoked_at IS NULL"),
+        masterInsert: uidb.prepare<[string, Buffer, number, number, number]>("INSERT INTO master_keys (label, secret, device_limit, server_id, created_at) VALUES (?, ?, ?, ?, ?)"),
+        masterUpdate: uidb.prepare<[string, number, number]>("UPDATE master_keys SET label = ?, device_limit = ? WHERE id = ?"),
+        masterSecret: uidb.prepare<[Buffer, number]>("UPDATE master_keys SET secret = ? WHERE id = ?"),
+        masterDelete: uidb.prepare<[number]>("DELETE FROM master_keys WHERE id = ?"),
+        serversOf:    uidb.prepare<[number]>("SELECT server_id FROM master_servers WHERE master_id = ? ORDER BY server_id"),
+        serverAdd:    uidb.prepare<[number, number]>("INSERT OR IGNORE INTO master_servers (master_id, server_id) VALUES (?, ?)"),
+        serverDel:    uidb.prepare<[number, number]>("DELETE FROM master_servers WHERE master_id = ? AND server_id = ?"),
+        usedServers:  uidb.prepare("SELECT server_id FROM master_servers UNION SELECT server_id FROM peer_tombstones"),
+        devicesOf:    uidb.prepare<[number]>("SELECT * FROM devices WHERE master_id = ? ORDER BY id"),
+        deviceById:   uidb.prepare<[number]>("SELECT * FROM devices WHERE id = ?"),
+        deviceByKey:  uidb.prepare<[number, string]>("SELECT * FROM devices WHERE master_id = ? AND device_id = ?"),
+        deviceCount:  uidb.prepare<[number]>("SELECT COUNT(*) AS n FROM devices WHERE master_id = ?"),
+        deviceInsert: uidb.prepare<[number, string, string, string, string, string, number, string]>(
+            "INSERT INTO devices (master_id, device_id, device_name, platform, pub_key, auth_pub, created_at, version) VALUES (?, ?, ?, ?, ?, ?, ?, ?)"),
+        deviceVersion: uidb.prepare<[string, number]>("UPDATE devices SET version = ? WHERE id = ?"),
+        deviceDelete: uidb.prepare<[number]>("DELETE FROM devices WHERE id = ?"),
+        deviceSeen:   uidb.prepare<[number, number]>("UPDATE devices SET last_seen = ? WHERE id = ?"),
+        devicePub:    uidb.prepare<[string, number, number]>("UPDATE devices SET pub_key = ?, rekey_requested = ? WHERE id = ?"),
+        deviceFlag:   uidb.prepare<[number, number]>("UPDATE devices SET rekey_requested = 1 WHERE id = ? OR master_id = ?"),
+        linksOf:      uidb.prepare<[number]>("SELECT * FROM device_peers WHERE device_id = ? ORDER BY server_id"),
+        linkAdd:      uidb.prepare<[number, number]>("INSERT OR IGNORE INTO device_peers (device_id, server_id) VALUES (?, ?)"),
+        linkDel:      uidb.prepare<[number, number]>("DELETE FROM device_peers WHERE device_id = ? AND server_id = ?"),
+        linkSet:      uidb.prepare<[string | null, string | null, string | null, number, number, number]>(
+            "UPDATE device_peers SET peer_pub = ?, ip = ?, psk = ?, psk_pending = ? WHERE device_id = ? AND server_id = ?"),
+        linkPskDue:   uidb.prepare<[number]>("UPDATE device_peers SET psk_pending = 1 WHERE device_id = ? AND peer_pub IS NOT NULL"),
+        // Что на сервере расходится с нужным: пира нет, стоит старый ключ, не знаем ip/psk, ждёт новый PSK.
+        linksToFix:   uidb.prepare<[number]>(`
+            SELECT l.*, d.pub_key AS dev_pub, d.master_id FROM device_peers l JOIN devices d ON d.id = l.device_id
+            WHERE l.server_id = ? AND (l.peer_pub IS NULL OR l.peer_pub <> d.pub_key
+                                       OR l.ip IS NULL OR l.psk IS NULL OR l.psk_pending = 1)`),
+        tombsOf:      uidb.prepare<[number]>("SELECT pub_key FROM peer_tombstones WHERE server_id = ?"),
+        tombAdd:      uidb.prepare<[number, string]>("INSERT OR IGNORE INTO peer_tombstones (server_id, pub_key) VALUES (?, ?)"),
+        tombDel:      uidb.prepare<[number, string]>("DELETE FROM peer_tombstones WHERE server_id = ? AND pub_key = ?"),
+        profileGet:   uidb.prepare<[number]>("SELECT profile FROM server_profiles WHERE server_id = ?"),
+        profileSet:   uidb.prepare<[number, string, number]>(
+            "INSERT INTO server_profiles (server_id, profile, updated_at) VALUES (?, ?, ?) ON CONFLICT(server_id) DO UPDATE SET profile = excluded.profile, updated_at = excluded.updated_at"),
+    };
+
+    const now = () => Math.floor(Date.now() / 1000);
+    const hasCtrlOk = (s: number) => s >= 200 && s < 300;
+    const serverIdsOf = (masterId: number) => (q.serversOf.all(masterId) as { server_id: number }[]).map(r => r.server_id);
+
+    // ── Сведение серверов ──────────────────────────────────────────────────
+    function storedProfile(id: number): Profile | null {
+        const row = q.profileGet.get(id) as { profile: string } | undefined;
+        try { return row ? JSON.parse(row.profile) as Profile : null; } catch { return null; }
+    }
+
+    async function refreshProfile(id: number, ctrl: Ctrl): Promise<boolean> {
+        const r = await ctrl("GET", "/api/profile");
+        if (!hasCtrlOk(r.status) || typeof r.data?.endpoint !== "string") return false;
+        const json = JSON.stringify(r.data);
+        const row = q.profileGet.get(id) as { profile: string } | undefined;
+        if (row?.profile !== json) q.profileSet.run(id, json, now());
+        return true;
+    }
+
+    // Один проход на сервер за раз: параллельные проходы добавили бы одного пира дважды.
+    const locks = new Map<number, Promise<void>>();
+    function reconcile(id: number): Promise<void> {
+        const next = (locks.get(id) ?? Promise.resolve()).then(() => reconcileNow(id)).catch(e => {
+            console.warn(`sub: сервер #${id} не сведён: ${(e as Error).message}`);
+        });
+        locks.set(id, next);
+        return next;
+    }
+    const reconcileAll = (ids: Iterable<number>) => Promise.all([...new Set(ids)].map(reconcile));
+
+    async function reconcileNow(id: number) {
+        if (!servers.exists(id) || !servers.isOnline(id)) return;
+        const ctrl = servers.ctrlFor(id);
+        if (!await refreshProfile(id, ctrl)) return;            // сервер не отвечает — попробуем позже
+
+        // Список пиров сервера — лениво, только если понадобится (409, потерянный ip/psk).
+        let listed: Map<string, { ip: string; psk_key: string }> | null = null;
+        const onServer = async (pub: string) => {
+            if (!listed) {
+                const r = await ctrl("GET", "/api/peers");
+                if (!hasCtrlOk(r.status)) throw new Error(`peers ${r.status}`);
+                listed = new Map((r.data.peers as { pub_key: string; ip: string; psk_key: string }[]).map(p => [p.pub_key, p]));
+            }
+            return listed.get(pub) ?? null;
+        };
+        const gone = (s: number) => s === 502 || s === 504;    // связь пропала посреди прохода
+
+        for (const { pub_key } of q.tombsOf.all(id) as { pub_key: string }[]) {
+            const r = await ctrl("DELETE", `/api/peers/${pubParam(pub_key)}`);
+            if (hasCtrlOk(r.status) || r.status === 404) q.tombDel.run(id, pub_key);
+            else if (gone(r.status)) return;
+        }
+
+        type Peer = { ip: string; psk_key: string };
+        for (const l of q.linksToFix.all(id) as (LinkRow & { dev_pub: string; master_id: number })[]) {
+            // null — не вышло, попробуем в следующий проход; "gone" — связь пропала, проход прекращаем.
+            const add = async (): Promise<Peer | null | "gone"> => {
+                const r = await ctrl("POST", "/api/peers", { pub_key: l.dev_pub, owner: `m${l.master_id}/d${l.device_id}` });
+                if (hasCtrlOk(r.status)) return r.data;
+                if (r.status === 409) return onServer(l.dev_pub);      // уже добавлен, но ответ потерялся
+                return gone(r.status) ? "gone" : null;
+            };
+
+            let peer: Peer | null | "gone";
+            if (l.peer_pub === null) {
+                peer = await add();
+            } else if (l.peer_pub !== l.dev_pub) {
+                // Ключ сменили, пока сервер был недоступен: тот же IP и PSK, новый ключ.
+                const r = await ctrl("PUT", `/api/peers/${pubParam(l.peer_pub)}`, { pub_key: l.dev_pub });
+                peer = hasCtrlOk(r.status) ? r.data
+                    : r.status === 404 ? await add()                    // старого пира на сервере уже нет
+                    : r.status === 409 ? await onServer(l.dev_pub)
+                    : gone(r.status) ? "gone" : null;
+            } else {
+                peer = await onServer(l.dev_pub) ?? await add();         // ip/psk не знаем или пир пропал с сервера
+            }
+            if (peer === "gone") return;
+            if (!peer) continue;
+
+            let pending = 0;
+            if (l.psk_pending === 1) {
+                const r = await ctrl("POST", `/api/peers/${pubParam(l.dev_pub)}/psk`);
+                if (hasCtrlOk(r.status)) peer = r.data as Peer;
+                else if (gone(r.status)) return;
+                else pending = 1;                                        // пир на месте, PSK сменим позже
+            }
+            q.linkSet.run(l.dev_pub, peer.ip, peer.psk_key, pending, l.device_id, id);
+        }
+    }
+
+    /** Устройство удаляется: его пиров — в список на удаление, строку — из реестра. */
+    function forgetDevice(dev: DeviceRow): number[] {
+        const links = q.linksOf.all(dev.id) as LinkRow[];
+        uidb.transaction(() => {
+            for (const l of links) if (l.peer_pub) q.tombAdd.run(l.server_id, l.peer_pub);
+            q.deviceDelete.run(dev.id);                         // device_peers уйдут каскадом
+        })();
+        return links.map(l => l.server_id);
+    }
+
+    // ── config ─────────────────────────────────────────────────────────────
+    const hostOf = (endpoint: string) => endpoint.slice(0, endpoint.lastIndexOf(":"));
+
+    function subHost(req?: Request): string {
+        if (SUB_HOST) return SUB_HOST;
+        const local = servers.exists(0) ? storedProfile(0) : null;
+        if (local) return hostOf(local.endpoint);
+        return (req?.hostname ?? "").replace(/^\[|\]$/g, "");
+    }
+
+    // В servers[] — только серверы, где уже стоит текущий ключ устройства и известны ip/psk.
+    // Сервер, который ещё не догнали (нода не в сети при регистрации или смене ключа), появится,
+    // когда его сведут, — rev при этом сменится, и клиент подтянет.
+    function buildConfig(dev: DeviceRow, req?: Request) {
+        const list = [];
+        for (const l of q.linksOf.all(dev.id) as LinkRow[]) {
+            const prof = storedProfile(l.server_id);
+            if (!prof || l.peer_pub !== dev.pub_key || !l.ip || !l.psk) continue;
+            list.push({
+                id: l.server_id, name: prof.name, endpoint: prof.endpoint, server_pub: prof.server_pub,
+                psk: l.psk, address: `${l.ip}/32`, dns: prof.dns,
+                keepalive: prof.keepalive, mtu: prof.mtu, gen: prof.gen, awg: prof.awg,
+            });
+        }
+        const cfg = {
+            rekey: dev.rekey_requested === 1,
+            endpoints: [`${subHost(req)}:${SUB_PORT}`],
+            servers: list,
+        };
+        // rev меняется при любом изменении; клиент по нему решает, трогать ли туннель.
+        const rev = crypto.createHash("sha256").update(JSON.stringify(cfg)).digest("hex").slice(0, 16);
+        return { rev, ...cfg };
+    }
+
+    // Конфиг, в котором есть хотя бы один сервер. Пустой не отдаём: клиент снёс бы туннель
+    // из-за временной недоступности нод — пусть лучше живёт со старым конфигом.
+    async function readyConfig(dev: DeviceRow, req: Request) {
+        let cfg = buildConfig(dev, req);
+        if (cfg.servers.length === 0) {
+            await reconcileAll((q.linksOf.all(dev.id) as LinkRow[]).map(l => l.server_id));
+            cfg = buildConfig(q.deviceById.get(dev.id) as DeviceRow, req);
+        }
+        if (cfg.servers.length === 0) throw new Error("no servers");
+        return cfg;
+    }
+
+    // ── Публичная часть: /sub/v1 ───────────────────────────────────────────
+    const sub = express();
+    sub.disable("x-powered-by");
+    sub.use(express.json({
+        limit: "4kb",
+        verify: (req, _res, buf) => { (req as any).rawBody = buf; },
+    }));
+
+    const registerLimit = makeLimiter(30, 15 * 60 * 1000);
+    const failLimit     = makeLimiter(30, 15 * 60 * 1000);
+    const seenSigs      = new Map<string, number>(); // подпись → когда забыть
+
+    function send(res: Response, status: number, payload: unknown) {
+        res.status(status).json(signResponse(payload, signKey as crypto.KeyObject));
+    }
+
+    // Проверка подписи запроса + защита от повторов. auth_pub — 32 байта.
+    function checkSigned(req: Request, authPub: Buffer): boolean {
+        const ts  = Number(req.headers["x-sen-ts"]);
+        const sig = String(req.headers["x-sen-sig"] ?? "");
+        if (!Number.isInteger(ts) || Math.abs(ts - now()) > TS_WINDOW || !sig) return false;
+        const body = ((req as any).rawBody as Buffer | undefined) ?? Buffer.alloc(0);
+        if (!verifyRequest(req.method, req.path, ts, body, sig, authPub)) return false;
+        const t = Date.now();
+        for (const [k, exp] of seenSigs) if (exp < t) seenSigs.delete(k);
+        if (seenSigs.has(sig)) return false;
+        seenSigs.set(sig, t + 2 * TS_WINDOW * 1000);
+        return true;
+    }
+
+    interface DevReq extends Request { device?: DeviceRow }
+
+    function deviceAuth(req: Request, res: Response, next: NextFunction) {
+        const id = Number(req.headers["x-sen-device"]);
+        const dev = Number.isInteger(id) ? q.deviceById.get(id) as DeviceRow | undefined : undefined;
+        if (dev && checkSigned(req, Buffer.from(dev.auth_pub, "base64url"))) {
+            (req as DevReq).device = dev;
+            next();
+            return;
+        }
+        // Лимитируем только неудачи: живой клиент, опрашивающий config, под лимит не попадает.
+        if (!failLimit(req.socket.remoteAddress ?? "unknown")) { send(res, 429, { error: "rate_limited" }); return; }
+        send(res, 401, { error: "unauthorized" });
+    }
+
+    const wrap = (fn: (req: Request, res: Response) => Promise<void>) =>
+        (req: Request, res: Response) => { fn(req, res).catch(() => { send(res, 502, { error: "unavailable" }); }); };
+
+    sub.post("/sub/v1/register", wrap(async (req, res) => {
+        const ip = req.socket.remoteAddress ?? "unknown";
+        if (!registerLimit(ip)) { send(res, 429, { error: "rate_limited" }); return; }
+
+        const b = (req.body ?? {}) as Record<string, unknown>;
+        const str = (v: unknown, re: RegExp) => typeof v === "string" && re.test(v) ? v : null;
+        const secretB = str(b.sub, /^[A-Za-z0-9_-]{22}$/);
+        const deviceId = str(b.device_id, /^[\w.-]{1,64}$/);
+        const pubKey = str(b.pub_key, B64_PUB);
+        const authPubS = str(b.auth_pub, /^[A-Za-z0-9_-]{43}$/);
+        const name = typeof b.device_name === "string" ? b.device_name.slice(0, 64) : "";
+        const platform = typeof b.platform === "string" ? b.platform.slice(0, 32) : "";
+        const version = str(b.version, CLIENT_VERSION) ?? "";
+        if (!secretB || !deviceId || !pubKey || !authPubS) { send(res, 400, { error: "bad_request" }); return; }
+
+        // Регистрация подписана ключом auth_pub из самого тела — доказательство владения.
+        const authPub = Buffer.from(authPubS, "base64url");
+        if (authPub.length !== 32 || !checkSigned(req, authPub)) { send(res, 401, { error: "unauthorized" }); return; }
+
+        const master = q.masterBySecret.get(Buffer.from(secretB, "base64url")) as MasterRow | undefined;
+        if (!master) { send(res, 404, { error: "not_found" }); return; }
+        const serverIds = serverIdsOf(master.id).filter(id => servers.exists(id));
+        if (serverIds.length === 0) { send(res, 502, { error: "unavailable" }); return; }
+
+        let deviceRowId = 0;
+        let touched: number[] = [];
+        try {
+            uidb.transaction(() => {
+                const existing = q.deviceByKey.get(master.id, deviceId) as DeviceRow | undefined;
+                if (existing) touched = forgetDevice(existing);         // переустановка — старые пиры на удаление
+                else if ((q.deviceCount.get(master.id) as { n: number }).n >= master.device_limit)
+                    throw Object.assign(new Error("limit"), { code: "limit" });
+                deviceRowId = Number(q.deviceInsert.run(master.id, deviceId, name, platform, pubKey, authPubS, now(), version).lastInsertRowid);
+                for (const sid of serverIds) q.linkAdd.run(deviceRowId, sid);
+            })();
+        } catch (e: any) {
+            if (e?.code === "limit") { send(res, 403, { error: "device_limit" }); return; }
+            send(res, 409, { error: "conflict" }); return; // UNIQUE: pub_key/auth_pub уже заняты
+        }
+
+        await reconcileAll([...touched, ...serverIds]);
+        const dev = q.deviceById.get(deviceRowId) as DeviceRow;
+        const cfg = buildConfig(dev, req);
+        if (cfg.servers.length === 0) {
+            // Ни один сервер пира не принял — регистрацию откатываем, клиент повторит позже.
+            await reconcileAll(forgetDevice(dev));
+            send(res, 502, { error: "unavailable" });
+            return;
+        }
+        // devices / device_limit: сколько мест занято с этим устройством — клиент показывает это сразу,
+        // без отдельного запроса списка.
+        send(res, 201, {
+            device: dev.id, config: cfg,
+            devices: (q.deviceCount.get(master.id) as { n: number }).n, device_limit: master.device_limit,
+        });
+    }));
+
+    // Сколько мест у ключа занято — клиент показывает это, пока ссылку только вставили и ещё ничего не
+    // регистрировали. Запрос не подписан устройством (его ещё нет): доступ по секрету из ссылки, как у register,
+    // а ответ подписан, как всегда. Неверный секрет считается в failLimit — секрет не перебрать.
+    sub.post("/sub/v1/peek", wrap(async (req, res) => {
+        const ip = req.socket.remoteAddress ?? "unknown";
+        const secretB = typeof (req.body as any)?.sub === "string" && /^[A-Za-z0-9_-]{22}$/.test((req.body as any).sub) ? (req.body as any).sub as string : null;
+        const master = secretB ? q.masterBySecret.get(Buffer.from(secretB, "base64url")) as MasterRow | undefined : undefined;
+        if (!master) {
+            if (!failLimit(ip)) { send(res, 429, { error: "rate_limited" }); return; }
+            send(res, secretB ? 404 : 400, { error: secretB ? "not_found" : "bad_request" });
+            return;
+        }
+        send(res, 200, { devices: (q.deviceCount.get(master.id) as { n: number }).n, device_limit: master.device_limit });
+    }));
+
+    sub.get("/sub/v1/config", deviceAuth, wrap(async (req, res) => {
+        const dev = (req as DevReq).device as DeviceRow;
+        q.deviceSeen.run(now(), dev.id);
+        // Версия клиента меняется при обновлении приложения; заголовок не подписан — это лишь подпись в панели.
+        const v = String(req.headers["x-sen-version"] ?? "");
+        if (CLIENT_VERSION.test(v) && v !== dev.version) q.deviceVersion.run(v, dev.id);
+        send(res, 200, { config: await readyConfig(dev, req) });
+    }));
+
+    // Устройства того же мастер-ключа: клиент показывает их на вкладке «Ключ». Только чтение — отвязать
+    // можно лишь себя (DELETE /sub/v1/device); чужие устройства убирает панель.
+    sub.get("/sub/v1/devices", deviceAuth, wrap(async (req, res) => {
+        const dev = (req as DevReq).device as DeviceRow;
+        const master = q.masterById.get(dev.master_id) as MasterRow | undefined;
+        if (!master) { send(res, 404, { error: "not_found" }); return; }
+        send(res, 200, {
+            name: master.label,
+            device_limit: master.device_limit,
+            devices: (q.devicesOf.all(master.id) as DeviceRow[]).map(d => ({
+                id: d.id, name: d.device_name, platform: d.platform, version: d.version,
+                created_at: d.created_at, last_seen: d.last_seen, current: d.id === dev.id,
+            })),
+        });
+    }));
+
+    // Новый ключ ставится на все серверы ключа: где сервер доступен — сразу (тот же IP и PSK),
+    // где нет — когда он появится. Если не принял ни один — ключ не меняем, клиент повторит.
+    sub.post("/sub/v1/rekey", deviceAuth, wrap(async (req, res) => {
+        const dev = (req as DevReq).device as DeviceRow;
+        const pub = (req.body as { pub_key?: unknown } | undefined)?.pub_key;
+        if (typeof pub !== "string" || !B64_PUB.test(pub)) { send(res, 400, { error: "bad_request" }); return; }
+        if (pub === dev.pub_key) { send(res, 200, { config: await readyConfig(dev, req) }); return; }
+        try { q.devicePub.run(pub, 0, dev.id); }
+        catch { send(res, 409, { error: "conflict" }); return; }  // этот ключ уже у другого устройства
+
+        const ids = (q.linksOf.all(dev.id) as LinkRow[]).map(l => l.server_id);
+        await reconcileAll(ids);
+        const cfg = buildConfig(q.deviceById.get(dev.id) as DeviceRow, req);
+        if (cfg.servers.length === 0) {
+            q.devicePub.run(dev.pub_key, dev.rekey_requested, dev.id);
+            await reconcileAll(ids);                             // вернуть старый ключ туда, где успели сменить
+            send(res, 502, { error: "unavailable" });
+            return;
+        }
+        send(res, 200, { config: cfg });
+    }));
+
+    sub.delete("/sub/v1/device", deviceAuth, wrap(async (req, res) => {
+        const dev = (req as DevReq).device as DeviceRow;
+        await reconcileAll(forgetDevice(dev));
+        send(res, 200, { ok: true });
+    }));
+
+    sub.use((_req, res) => { send(res, 404, { error: "not_found" }); });
+    // Битый JSON и т. п.: ответ всё равно подписан, чтобы клиент мог ему доверять.
+    sub.use((_err: unknown, _req: Request, res: Response, _next: NextFunction) => { send(res, 400, { error: "bad_request" }); });
+
+    // ── Админ-роуты панели (монтируются в server.ts за JWT) ─────────────────
+    const aw = (fn: (req: Request, res: Response) => Promise<void>) =>
+        (req: Request, res: Response) => { fn(req, res).catch(() => { res.status(502).json({ error: "awg-ctrl недоступен" }); }); };
+    const idOf = (req: Request) => Number(req.params.id);
+    const LABEL = /^[^\r\n<>]{1,40}$/;
+    const limitOk = (n: unknown): n is number => Number.isInteger(n) && (n as number) >= 1 && (n as number) <= 100;
+
+    // Набор серверов из тела запроса: непустой, без повторов, только существующие.
+    function parseServers(v: unknown): number[] | string {
+        if (!Array.isArray(v) || v.length === 0) return "Нужен хотя бы один сервер";
+        if (v.length > MAX_SERVERS) return `Не больше ${MAX_SERVERS} серверов`;
+        const ids = [...new Set(v)];
+        if (!ids.every(id => Number.isInteger(id) && servers.exists(id as number))) return "Такого сервера нет";
+        return (ids as number[]).sort((a, b) => a - b);
+    }
+
+    const masterKeys = Router();
+
+    masterKeys.get("/", (_req, res) => {
+        res.json({
+            enabled: signKey !== null,
+            tls: tlsPin !== null,
+            keys: (q.masters.all() as (MasterRow & { devices: number })[]).map(m => ({
+                id: m.id, label: m.label, device_limit: m.device_limit,
+                devices: m.devices, servers: serverIdsOf(m.id), created_at: m.created_at,
+            })),
+        });
+    });
+
+    masterKeys.post("/", (req, res) => {
+        const { label, device_limit, servers: wanted } = (req.body ?? {}) as { label?: string; device_limit?: number; servers?: unknown };
+        if (typeof label !== "string" || !LABEL.test(label)) { res.status(400).json({ error: "Метка: до 40 символов, без переводов строк и <>" }); return; }
+        const limit = device_limit === undefined ? DEFAULT_LIMIT : device_limit;
+        if (!limitOk(limit)) { res.status(400).json({ error: "Лимит устройств: от 1 до 100" }); return; }
+        const ids = parseServers(wanted === undefined ? [servers.defaultId()] : wanted);
+        if (typeof ids === "string") { res.status(400).json({ error: wanted === undefined ? "Сначала добавьте сервер" : ids }); return; }
+        let id = 0;
+        uidb.transaction(() => {
+            id = Number(q.masterInsert.run(label, crypto.randomBytes(16), limit, ids[0], now()).lastInsertRowid);
+            for (const sid of ids) q.serverAdd.run(id, sid);
+        })();
+        res.status(201).json({ id, label, device_limit: limit, devices: 0, servers: ids });
+    });
+
+    masterKeys.patch("/:id", aw(async (req, res) => {
+        const m = q.masterById.get(idOf(req)) as MasterRow | undefined;
+        if (!m) { res.status(404).json({ error: "Не найден" }); return; }
+        const { label, device_limit, servers: wanted } = (req.body ?? {}) as { label?: string; device_limit?: number; servers?: unknown };
+        const nl = label ?? m.label, nd = device_limit ?? m.device_limit;
+        if (typeof nl !== "string" || !LABEL.test(nl)) { res.status(400).json({ error: "Неверная метка" }); return; }
+        if (!limitOk(nd)) { res.status(400).json({ error: "Лимит устройств: от 1 до 100" }); return; }
+
+        let ids = serverIdsOf(m.id);
+        const affected: number[] = [];
+        if (wanted !== undefined) {
+            const next = parseServers(wanted);
+            if (typeof next === "string") { res.status(400).json({ error: next }); return; }
+            const added = next.filter(s => !ids.includes(s)), removed = ids.filter(s => !next.includes(s));
+            const devices = q.devicesOf.all(m.id) as DeviceRow[];
+            uidb.transaction(() => {
+                for (const sid of removed) {
+                    q.serverDel.run(m.id, sid);
+                    for (const d of devices) {
+                        const l = (q.linksOf.all(d.id) as LinkRow[]).find(x => x.server_id === sid);
+                        if (l?.peer_pub) q.tombAdd.run(sid, l.peer_pub);
+                        q.linkDel.run(d.id, sid);
+                    }
+                }
+                for (const sid of added) {
+                    q.serverAdd.run(m.id, sid);
+                    for (const d of devices) q.linkAdd.run(d.id, sid);
+                }
+            })();
+            affected.push(...added, ...removed);
+            ids = next;
+        }
+        q.masterUpdate.run(nl, nd, m.id);
+        await reconcileAll(affected);
+        res.json({ id: m.id, label: nl, device_limit: nd, servers: ids });
+    }));
+
+    masterKeys.post("/:id/rotate", (req, res) => {
+        const m = q.masterById.get(idOf(req)) as MasterRow | undefined;
+        if (!m) { res.status(404).json({ error: "Не найден" }); return; }
+        q.masterSecret.run(crypto.randomBytes(16), m.id); // устройства продолжают работать: у них auth_pub
+        res.json({ id: m.id });
+    });
+
+    masterKeys.post("/:id/rekey", (req, res) => {
+        const m = q.masterById.get(idOf(req)) as MasterRow | undefined;
+        if (!m) { res.status(404).json({ error: "Не найден" }); return; }
+        q.deviceFlag.run(-1, m.id);
+        res.json({ id: m.id });
+    });
+
+    masterKeys.delete("/:id", aw(async (req, res) => {
+        const m = q.masterById.get(idOf(req)) as MasterRow | undefined;
+        if (!m) { res.status(404).json({ error: "Не найден" }); return; }
+        const affected: number[] = [];
+        for (const d of q.devicesOf.all(m.id) as DeviceRow[]) affected.push(...forgetDevice(d));
+        q.masterDelete.run(m.id); // master_servers уйдут каскадом
+        await reconcileAll(affected);
+        res.json({ success: true, id: m.id });
+    }));
+
+    masterKeys.get("/:id/link", (req, res) => {
+        const m = q.masterById.get(idOf(req)) as MasterRow | undefined;
+        if (!m) { res.status(404).json({ error: "Не найден" }); return; }
+        if (!signKey || !signPub || !SUB_PORT) { res.status(503).json({ error: "Подписка не настроена на сервере" }); return; }
+        const host = subHost(req);
+        if (!host) { res.status(503).json({ error: "Не удалось определить адрес панели — задайте SUB_HOST" }); return; }
+        const link = encodeSenLink({
+            tls: tlsPin !== null,
+            addrs: [{ host, port: SUB_PORT }],
+            secret: m.secret, signPub, tlsPin: tlsPin ?? undefined, name: m.label,
+        });
+        res.json({ link, tls: tlsPin !== null });
+    });
+
+    // Статистика устройства — по всем серверам ключа: онлайн, если есть свежий handshake хоть
+    // на одном; трафик суммируется. servers_ok — на скольких серверах уже стоит его текущий ключ.
+    masterKeys.get("/:id/devices", aw(async (req, res) => {
+        const m = q.masterById.get(idOf(req)) as MasterRow | undefined;
+        if (!m) { res.status(404).json({ error: "Не найден" }); return; }
+        const stats = new Map<string, { online: boolean; lastHandshake: number; rx: number; tx: number }>();
+        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 };
+                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,
+                });
+            }
+        }));
+        res.json({
+            devices: (q.devicesOf.all(m.id) as DeviceRow[]).map(d => {
+                const links = q.linksOf.all(d.id) as LinkRow[];
+                const s = stats.get(d.pub_key);
+                return {
+                    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,
+                    servers_total: links.length, servers_ok: links.filter(l => l.peer_pub === d.pub_key && l.ip).length,
+                };
+            }),
+        });
+    }));
+
+    const devices = Router();
+
+    devices.delete("/:id", aw(async (req, res) => {
+        const d = q.deviceById.get(idOf(req)) as DeviceRow | undefined;
+        if (!d) { res.status(404).json({ error: "Не найдено" }); return; }
+        await reconcileAll(forgetDevice(d));
+        res.json({ success: true, id: d.id });
+    }));
+
+    devices.post("/:id/rekey", (req, res) => {
+        const d = q.deviceById.get(idOf(req)) as DeviceRow | undefined;
+        if (!d) { res.status(404).json({ error: "Не найдено" }); return; }
+        q.deviceFlag.run(d.id, -1);
+        res.json({ id: d.id });
+    });
+
+    // Новый PSK на каждом сервере; недоступные получат его, когда появятся.
+    devices.post("/:id/psk", aw(async (req, res) => {
+        const d = q.deviceById.get(idOf(req)) as DeviceRow | undefined;
+        if (!d) { res.status(404).json({ error: "Не найдено" }); return; }
+        q.linkPskDue.run(d.id);
+        await reconcileAll((q.linksOf.all(d.id) as LinkRow[]).map(l => l.server_id));
+        const pending = (q.linksOf.all(d.id) as LinkRow[]).filter(l => l.psk_pending === 1).length;
+        res.json({ id: d.id, pending });
+    }));
+
+    // ── Листенер и фоновое сведение ────────────────────────────────────────
+    servers.onOnline(id => { void reconcile(id); });
+
+    function start() {
+        // Сводим и без подписки: у ключей могут остаться хвосты на удаление.
+        setInterval(() => {
+            void reconcileAll((q.usedServers.all() as { server_id: number }[]).map(r => r.server_id));
+        }, SYNC_EVERY).unref();
+
+        if (!signKey) return;
+        if (!SUB_PORT) { console.warn("sub: SUB_PORT не задан — подписка отключена"); signKey = null; return; }
+        const server = tlsMaterial ? https.createServer(tlsMaterial, sub) : http.createServer(sub);
+        server.listen(SUB_PORT, () => {
+            console.log(`sub: listening on :${SUB_PORT} (${tlsMaterial ? "https" : "http"})`);
+        });
+    }
+
+    return { masterKeys, devices, start };
+}
@@ -1,6 +1,6 @@
 {
  "name": "awg-cli",
-  "version": "0.2.0",
+  "version": "0.3.2",
  "private": true,
  "dependencies": {
    "tsx": "^4.7.0",
@@ -1,7 +1,7 @@
 // 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 { spawn }                                from "child_process";
+import { spawn, spawnSync }                     from "child_process";
 import { readFileSync, writeFileSync, existsSync,
    mkdirSync, openSync, closeSync,
    unlinkSync }                           from "fs";
@@ -90,14 +90,67 @@ const SERVICES = {
            UI_USER:      process.env.UI_USER         ?? "admin",
            UI_PASS:      process.env.UI_PASS         ?? "",
            JWT_SECRET:   process.env.JWT_SECRET      ?? "",
+            // ui.db (ключи внешнего API) в каталоге данных AWG (вне PROJECT) —
+            // переживает переустановку.
+            UI_DB_FILE:   process.env.UI_DB_FILE      ?? "/etc/amnezia/amneziawg/ui.db",
+            // Подписка sen:// (мастер-ключи SenAWG): порт, режим TLS, ключ подписи и
+            // сертификат. Без SUB_PORT или ключа подписи awg-ui подписку не поднимает.
+            SUB_PORT:          process.env.SUB_PORT          ?? "",
+            SUB_TLS:           process.env.SUB_TLS           ?? "off",
+            SUB_SIGN_KEY_FILE: process.env.SUB_SIGN_KEY_FILE ?? "/etc/amnezia/amneziawg/sub_sign.key",
+            SUB_TLS_KEY_FILE:  process.env.SUB_TLS_KEY_FILE  ?? "/etc/amnezia/amneziawg/sub_tls.key",
+            SUB_TLS_CERT_FILE: process.env.SUB_TLS_CERT_FILE ?? "/etc/amnezia/amneziawg/sub_tls.crt",
+            // Публичный адрес панели в sen://-ссылках и endpoints. Пусто — адрес локального
+            // сервера (у панели без своего VPN — тот, по которому к ней зашли).
+            SUB_HOST:          process.env.SUB_HOST          ?? "",
+            // Приём нод (core): порт хаба WSS и его самоподписанный сертификат (pin зашит в
+            // join-строки, живёт как sub_tls.*). Без NODE_PORT хаб выключен. LOCAL_NODE=off —
+            // core без собственного VPN: awg-ctrl рядом не нужен.
+            NODE_PORT:          process.env.NODE_PORT          ?? "",
+            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",
        },
        pidFile: "/tmp/awg-ui.pid",
        logFile: path.join(LOGS, "awg-ui.log"),
    },
+    // Агент ноды: сам звонит в core (CORE_HOST/PORT/PIN из join-строки) и исполняет запросы
+    // на локальном awg-ctrl. Запускается вместо awg-ui — см. ROLE.
+    agent: {
+        label:   "awg-agent",
+        cwd:     path.join(ROOT, "awg-agent"),
+        entry:   "index.ts",
+        env: {
+            CORE_HOST:     process.env.CORE_HOST     ?? "",
+            CORE_PORT:     process.env.CORE_PORT     ?? "",
+            CORE_PIN:      process.env.CORE_PIN      ?? "",
+            NODE_ID:       process.env.NODE_ID       ?? "",
+            NODE_KEY_FILE: process.env.NODE_KEY_FILE ?? "/etc/amnezia/amneziawg/node.key",
+            JOIN_SECRET:   process.env.JOIN_SECRET   ?? "",
+            CLI_ENV_FILE:  envFile,
+            AWGCTRL_PORT:  process.env.AWGCTRL_PORT  ?? "3005",
+            INTERNAL_AUTH_KEY_FILE: process.env.INTERNAL_AUTH_KEY_FILE
+                ?? "/etc/amnezia/amneziawg/internal_auth_private.key",
+        },
+        pidFile: "/tmp/awg-agent.pid",
+        logFile: path.join(LOGS, "awg-agent.log"),
+    },
 } as const;

 type SvcName = keyof typeof SERVICES;
-const ALL: SvcName[] = ["awgctrl", "ui"];
+
+// Роль установки. node — VPN-сервер без панели: awg-ctrl + агент, который сам
+// подключается к core (есть CORE_HOST, его пишет `join`). core с LOCAL_NODE=off —
+// панель без собственного VPN (только awg-ui). Иначе — обычная установка.
+const IS_NODE = !!process.env.CORE_HOST;
+const NO_LOCAL = (process.env.LOCAL_NODE ?? "on").toLowerCase() === "off";
+// Нода со своей панелью: работающий сервер «панель + VPN» подключили к главной панели, не
+// выключая его собственную (join без --no-panel). Обе панели ходят в один awg-ctrl — он и
+// есть источник правды, поэтому друг другу они не мешают. У ноды, поставленной install.sh,
+// панели нет (UI_PASS не задан).
+const NODE_PANEL = IS_NODE && !!process.env.UI_PASS && (process.env.NODE_PANEL ?? "on").toLowerCase() !== "off";
+const ALL: SvcName[] = IS_NODE ? (NODE_PANEL ? ["awgctrl", "ui", "agent"] : ["awgctrl", "agent"])
+    : NO_LOCAL ? ["ui"] : ["awgctrl", "ui"];

 function readPid(name: SvcName): number | null {
    const { pidFile } = SERVICES[name];
@@ -260,7 +313,7 @@ function probe(url: string, timeoutMs = 1000): Promise<boolean> {

 // Ждём, пока awg-ctrl начнёт отвечать. Если процесс умер (например,
 // ensureInterfaceUp() бросил исключение) — сразу выходим.
-async function waitForHealth(name: SvcName, attempts = 10): Promise<boolean> {
+async function waitForHealth(name: "awgctrl", attempts = 10): Promise<boolean> {
    const url = `http://127.0.0.1:${SERVICES[name].env.PORT}/health`;
    for (let i = 0; i < attempts; i++) {
        if (!isRunning(name)) return false;
@@ -271,12 +324,16 @@ async function waitForHealth(name: SvcName, attempts = 10): Promise<boolean> {
 }

 async function startAll() {
+    // Панель без своего VPN: awg-ctrl рядом нет, health-gate не нужен.
+    if (!ALL.includes("awgctrl")) { for (const n of ALL) await start(n); return; }
+
    await start("awgctrl");
+    const rest = ALL.filter(n => n !== "awgctrl");
    if (!isRunning("awgctrl") || !(await waitForHealth("awgctrl"))) {
-        console.error(`  ${grey("■")} awg-ctrl не отвечает — awg-ui не запущен (см. ${SERVICES.awgctrl.logFile})`);
+        console.error(`  ${grey("■")} awg-ctrl не отвечает — ${rest.map(n => SERVICES[n].label).join(", ")} не запущен (см. ${SERVICES.awgctrl.logFile})`);
        return;
    }
-    await start("ui");
+    for (const n of rest) await start(n);
 }

 async function stopAll()    { for (const n of ALL) await stop(n); }
@@ -289,6 +346,68 @@ function updateEnvVar(content: string, key: string, value: string): string {
        : content.trimEnd() + `\n${key}=${value}\n`;
 }

+function removeEnvVar(content: string, key: string): string {
+    return content.split("\n").filter(l => !l.startsWith(`${key}=`)).join("\n");
+}
+
+// Роль читается из окружения при старте процесса, поэтому после смены cli.env
+// перезапуск делаем свежим процессом CLI, а не в этом же.
+function restartFresh(): void {
+    spawnSync(process.execPath, [...process.execArgv, process.argv[1], "restart"], { stdio: "inherit" });
+}
+
+// `join <awgjoin://…> [--no-panel]`: подключить эту установку к главной панели как ноду. Рядом
+// запускается агент; awg-ctrl и пользователи остаются как были. Своя панель (awg-ui) продолжает
+// работать, если она здесь есть, — с --no-panel она останавливается.
+async function joinCore(link?: string, flag?: string) {
+    if (!link?.startsWith("awgjoin://") || (flag !== undefined && flag !== "--no-panel")) {
+        console.error("  Usage: awg-ctrl join <awgjoin://…> [--no-panel]   (ссылку даёт панель: «Добавить сервер»)");
+        process.exit(1);
+    }
+    let j: { v?: number; h?: string; p?: number; pin?: string; n?: number; s?: string };
+    try { j = JSON.parse(Buffer.from(link.slice("awgjoin://".length), "base64url").toString("utf8")); }
+    catch { console.error("  Ссылка повреждена"); process.exit(1); }
+    const ok = j.v === 1 && typeof j.h === "string" && /^[A-Za-z0-9.:_-]{1,253}$/.test(j.h)
+        && Number.isInteger(j.p) && j.p! > 0 && j.p! < 65536
+        && typeof j.pin === "string" && /^[A-Za-z0-9_-]{43}$/.test(j.pin)
+        && Number.isInteger(j.n) && j.n! > 0 && typeof j.s === "string" && /^[A-Za-z0-9_-]{22}$/.test(j.s);
+    if (!ok) { console.error("  Ссылка неверного формата или от другой версии панели"); process.exit(1); }
+    if (IS_NODE && !await confirmYes(`  Эта нода уже подключена к ${process.env.CORE_HOST}. Перепривязать?`)) return;
+
+    const keepPanel = flag !== "--no-panel" && !!process.env.UI_PASS;
+    let content = existsSync(envFile) ? readFileSync(envFile, "utf8") : "";
+    const set: Record<string, string> = {
+        CORE_HOST: j.h!, CORE_PORT: String(j.p), CORE_PIN: j.pin!, NODE_ID: String(j.n), JOIN_SECRET: j.s!,
+        NODE_PANEL: keepPanel ? "on" : "off",
+    };
+    for (const [k, v] of Object.entries(set)) content = updateEnvVar(content, k, v);
+    writeFileSync(envFile, content, { mode: 0o600 });
+
+    if (!keepPanel) await stop("ui");
+    console.log(`\n  ${green("✓")} Настроено: core ${j.h}:${j.p}, нода #${j.n}` +
+        (keepPanel ? " · своя панель продолжает работать" : process.env.UI_PASS ? " · своя панель остановлена" : ""));
+    restartFresh();
+}
+
+async function unjoinCore() {
+    if (!IS_NODE) { console.log("  Эта установка не подключена к core"); return; }
+    await stop("agent");
+    let content = existsSync(envFile) ? readFileSync(envFile, "utf8") : "";
+    for (const k of ["CORE_HOST", "CORE_PORT", "CORE_PIN", "NODE_ID", "JOIN_SECRET", "NODE_PANEL"]) content = removeEnvVar(content, k);
+    writeFileSync(envFile, content, { mode: 0o600 });
+    console.log(`  ${green("✓")} Нода отвязана. Удалите её в панели (сервер) и запустите: awg-ctrl restart`);
+    // Нода, поставленная install.sh с ролью «нода», панели не имеет — без пароля в неё не войти.
+    if (!process.env.UI_PASS)
+        console.log(`  ${dim("Панель на этой машине не настроена: задайте логин и пароль — awg-ctrl credentials")}`);
+}
+
+async function confirmYes(q: string): Promise<boolean> {
+    const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+    const a = await new Promise<string>(r => rl.question(`${q} [y/N] `, r));
+    rl.close();
+    return /^y/i.test(a.trim());
+}
+
 async function setCredentials(field?: "user" | "pass") {
    const rl  = readline.createInterface({ input: process.stdin, output: process.stdout });
    const ask = (q: string) => new Promise<string>(r => rl.question(q, r));
@@ -383,9 +502,9 @@ async function main() {
        return;
    }

-    const USAGE = "Usage: cli <start|stop|restart|status|credentials [user|pass]>";
+    const USAGE = "Usage: cli <start|stop|restart|status|credentials [user|pass]|join <awgjoin://…> [--no-panel]|unjoin>";

-    const [,,, sub] = process.argv;
+    const [,,, sub, arg] = process.argv;

    switch (cmd) {
        case "start":       await startAll();                                  break;
@@ -397,6 +516,8 @@ async function main() {
            else if (sub === "pass") await setCredentials("pass");
            else await setCredentials();
            break;
+        case "join":        await joinCore(sub, arg);                          break;
+        case "unjoin":      await unjoinCore();                                break;
        default: console.log(USAGE); process.exit(1);
    }
 }
Author	SHA1	Message	Date
maeneko	3eede2f015	Bump to Beta 0.3.2 release / release (push) Successful in 3m35s Details All seven places the version is written down: .env, the copy in install.sh, the four package.json files and the /ui/brand example in the README. A master key can serve its devices from several servers; a server that joins a core as a node keeps its own panel.	2026-09-26 21:44:25 +03:00
maeneko	2054122110	Serve a master key's devices from several servers A master key now has a set of servers (the panel's own and/or nodes). A device's single WireGuard key becomes a peer on every server of its key, each with its own IP and PSK, and config.servers[] lists them all. - ui.db: master_servers (the key's set, never empty), device_peers (which key is on which server, with the ip/psk that server issued), peer_tombstones (peers to delete) and server_profiles (last known profile of each server). - Nothing is pushed blindly: reconcile() brings one server to the desired state - deletes tombstones, adds peers, rekeys with PUT, fills ip/psk, rotates a pending PSK - one pass per server at a time. It runs right after every action, when a node connects and once a minute, so a node that was offline catches up on rekeys, PSK changes and removals. - config is built from ui.db, so an offline node stays in it and rev does not flap; a server is listed once its peer carries the device's current key. An empty config is never sent (502 instead); register and rekey roll back if no server accepted the key. - Existing keys and devices migrate on start. With one server the config and its rev are byte-identical to 0.3.1 (checked by running both versions on the same ui.db), so existing clients notice nothing. - Panel: server checkboxes in the key settings instead of the placeholder (the last one cannot be removed), "на N из M серверов" on devices that have not reached every server yet, device stats summed over servers. - SUB_HOST: the panel's public address for sen:// links and endpoints; install.sh writes it. Without it a panel with no VPN of its own used the address it was opened at. - A node referenced by a key's server set cannot be deleted.	2026-09-26 21:43:58 +03:00
maeneko	129f29d6be	Keep the node's own panel when it joins a core A server that already works as panel + VPN can now also be a node of another panel without losing its own: `awg-ctrl join` keeps awg-ui running next to the agent and writes NODE_PANEL=on. `--no-panel` stops it as before. Both panels talk to the same awg-ctrl, which stays the source of truth, so they do not get in each other's way. The CLI runs awg-ctrl, awg-ui and awg-agent on such a node, all behind the awg-ctrl health gate; a node installed by install.sh has no UI_PASS and still runs only awg-ctrl + agent. unjoin also drops NODE_PANEL.	2026-09-26 21:43:45 +03:00
maeneko	2f2f0e268a	Bump to Beta 0.3.1 release / release (push) Successful in 3m18s Details Covers all seven places the version is written down: .env, the copy install.sh keeps because it prints its banner and builds the release URL before the archive with .env exists, the four package.json files (awg-agent is new), and the /ui/brand example in the README. Multiple servers under one panel (core + nodes), the installer's role question and its full log.	2026-09-26 20:19:50 +03:00
maeneko	2e773deba2	Fix the installer's generated password, keep going if the log dies Found by running install.sh end to end in a sandbox for all three roles. - The suggested UI password and JWT_SECRET came from `tr < /dev/urandom \| head -c N \|\| openssl rand`. Under pipefail tr's SIGPIPE made the pipeline fail every time, so openssl ran too and the two outputs were glued together (a 24-character password). rand_alnum() reads a finite 1 KiB instead. - The log filter runs sed with LC_ALL=C, so broken UTF-8 in someone else's output (make.log, dmesg) cannot stop it, and tee -p keeps writing to the screen if the log writer dies instead of taking the installer down with a silent SIGPIPE. - Output: labels before awg-quick up and apt-mark hold, no double blank lines, "маршрут" only where there is a VPN, a hint when the agent log is still empty.	2026-09-26 20:19:44 +03:00
maeneko	aa31b7b8a2	Ask for the server role in the installer, log everything - install.sh asks the role first: panel + VPN (as before), panel only (skips AmneziaWG, the kernel module and the headers/virt checks) or node (no panel; takes the awgjoin:// string and checks the panel's cert pin with openssl before building anything). ROLE= / JOIN= skip the questions; an update keeps the previous role. - The previous cli.env is read before a reinstall removes the project directory. Before this, keeping data silently lost SUB_PORT / SUB_TLS and broke every issued sen:// link. - Output: a header, numbered steps, menus, a summary before installing and a final block per role. The full output of apt, DKMS, npm, awg-quick, ufw and systemctl is shown as a dimmed block under its step, including what used to go to /dev/null. - The log starts with the first line: checks, questions with answers (password masked), all command output. It is written without colour codes, mode 600.	2026-09-26 19:48:34 +03:00
maeneko	789538756a	Manage several servers from one panel: core + nodes A node is a VPN server without a panel. awg-agent on it dials the panel (core) over an outbound WSS connection and runs the panel's requests on its own awg-ctrl, which stays on 127.0.0.1 and is unchanged. No inbound port on the node, works behind NAT. - awg-ui/nodes.ts: node registry in ui.db, WSS hub on NODE_PORT with a self-signed cert whose SPKI pin goes into the join string, RPC with timeouts, health polling, /ui/nodes routes. - Nodes enroll with a one-time awgjoin:// string (secret stored hashed, 1 hour) and then authenticate by their own Ed25519 key. The agent checks the pin before sending anything and only forwards /health, /api/, /awg/. - server_id 0 is the panel's own awg-ctrl; LOCAL_NODE=off makes the panel run without a VPN of its own. The panel picks a server with X-Server-Id, API keys use their server_id. sen:// still serves one server. - UI: a card per server in the server bar, switching remounts the tab, «Добавить сервер» gives the join command. - CLI: agent service, roles from cli.env, join / unjoin commands. - Release archives include awg-agent.	2026-09-26 19:48:33 +03:00
maeneko	1278ad527d	Add /sub/v1/devices and /sub/v1/peek, count the slots on register release / release (push) Successful in 3m14s Details - GET /sub/v1/devices: a device lists the devices of its own master key (name, platform, version, last seen, and which one is asking). Read-only: unbinding is still only DELETE /sub/v1/device for oneself. - POST /sub/v1/peek: how many slots of a key are taken, asked with the link's secret before any device exists, so the client can show it while the link is only pasted. Wrong secrets count against the failure limit. - register also answers with devices / device_limit, so the client needs no second request to show the slot it just took.	2026-09-25 17:24:52 +03:00
maeneko	6e010a0141	Bump to Beta 0.3.0 Covers all six places the version is written down: .env, the copy install.sh keeps because it prints its banner and builds the release URL before the archive with .env exists, the three package.json files, and the /ui/brand example in the README. First release with the sen:// subscription and master keys.	2026-09-25 17:24:52 +03:00
maeneko	923bd87fe9	Add sen:// subscription with master keys A master key is a sen:// link with a device limit. Each device generates its own WireGuard keypair and registers only the public key, then polls a signed /sub/v1/config, so params and generation changes reach users without re-importing a key. - awg-ctrl: peers table and /api/peers*, /api/profile; nextIp and rebuildConf take peers into account (output unchanged without them) - awg-ui: link codec and signatures (sen.ts), registry, panel routes and the public listener on SUB_PORT (sub.ts) - responses are always Ed25519-signed; TLS with a pinned self-signed certificate is optional - devices report a client version, shown as platform-version - "Мастер-ключи" tab: a table with the devices nested under each key, a device-limit meter, per-key settings and a placeholder for the servers a key serves; cards on mobile - install.sh/CLI: subscription signing key, optional certificate, port; kept across reinstalls with KEEP_DATA - add the missing mock-server.ts used by npm run dev:mock	2026-09-25 17:24:52 +03:00
maeneko	d5e00ddaf8	Bump to Beta 0.2.2 Covers all six places the version is written down: .env, the copy install.sh keeps because it prints its banner and builds the release URL before the archive with .env exists, the three package.json files, and the /ui/brand example in the README.	2026-09-10 17:51:19 +03:00
maeneko	2b46d04af9	Support Debian in the installer install.sh only knew Ubuntu. On Debian 13 the dependency step died on software-properties-common, which trixie no longer ships, and on linux-headers-generic, which Debian never had — so add-apt-repository and the Ubuntu headers meta package are both off the table there. The distro family now comes from /etc/os-release (derivatives via ID_LIKE) and shows up as its own line in the compatibility checklist. On Debian the amnezia PPA is wired by hand: the key is fetched from keyserver.ubuntu.com by its full fingerprint and checked after download, then a signed-by source is written on the Ubuntu series whose glibc is not newer than the Debian release's (bullseye→focal, bookworm→jammy, trixie→noble; AMNEZIA_PPA_SUITE overrides). Headers are installed as a separate step so a missing package gets precise advice instead of a generic failure. Debian's archive keeps only the latest kernel build, so a server that hasn't rebooted in a while has no headers for its running kernel; the hint names linux-image/linux-headers for the kernel's own flavour (cloud-amd64 and so on) plus a reboot. iptables joins the dependencies — PostUp calls it, and a minimal Debian 13 on nftables doesn't have it. IP forwarding moves to its own file in /etc/sysctl.d: Debian 13 no longer reads /etc/sysctl.conf at boot, so the old line would have held only until the first reboot.	2026-09-10 17:51:19 +03:00
maeneko	a358504e2a	Bump to Beta 0.2.1 release / release (push) Successful in 3m31s Details ci / check (push) Successful in 6m8s Details Covers all six places the version is written down: .env, the copy install.sh keeps because it prints its banner and builds the release URL before the archive with .env exists, the three package.json files, and the /ui/brand example in the README.	2026-09-10 00:24:18 +03:00
maeneko	66ae59e1d0	Add the admin panel scaffold A self-contained template: an Express backend with login, JWT, rate limiting and SPA serving, and a React 18 + Vite shell with the same tab registry and warm Material 3 design system the panel uses. No domain logic — routes and tabs are meant to be hung off it. node_modules and the frontend build stay out through the existing ignores.	2026-09-10 00:24:18 +03:00
maeneko	a11cfc88de	Bring back the external API keys Commit `0dbb13f` removed the whole feature: the apikeys tab, the /ui/apikeys routes, requireApiKey, the /api/v1 router, the ApiKey type, the better-sqlite3 dependency and UI_DB_FILE in the CLI and the installer. Only the untracked awg-ui/API.md survived, so the README went on to claim there was no key-based API at all. Restores all of it: ui.db with the api_keys table, awgk_ key generation storing only the SHA-256 and a display prefix, the JWT-guarded CRUD, and the /api/v1 router mounted before the JWT proxy on /api so the key auth is not swallowed. The tab comes back as its own folder and the registry picks it up on its own. UI_DB_FILE points at /etc/amnezia/amneziawg/ui.db, outside the install tree, so reinstalling keeps the keys; a fresh install moves the old one aside with its WAL sidecars. better-sqlite3 takes the slot of jsonwebtoken, which arrived with the MA7 integration and has been unused since `068cab4` removed it. One defect is not reproduced: the /api/v1 handlers called ctrl() without a try/catch, and Express 4 does not catch async rejections, so a single request with awg-ctrl down killed the panel process. They now answer 502 like proxy() already did. The API contract is documented in the README rather than linked: .gitignore excludes every markdown but README.md, so awg-ui/API.md is not in the repo and the link would break on a clone. Checked against a running server: login, key create/list/delete, 400 on a bad label, 401 without a JWT, "API key required" rather than "Unauthorized" on /api/v1, "Invalid API key" for a deleted key, last_used updating, and all three /api/v1 routes returning 502 with the process still alive.	2026-09-10 00:24:18 +03:00
maeneko	44c032b376	Document the panel API in the README The public /api/v1 surface and its docs went away with the API keys, leaving nothing written down about what the panel exposes — even though every route it uses is reachable over HTTP with a login token. Replaces the install-source section with an API chapter: the JWT flow and its 401/429 cases, the unauthenticated /ui/brand, health and interface status, the user routes including why fetching a key is a POST, reissue, and the 2.0 to 3.1 upgrade with its 409 and 500 cases. What is left of the install-source notes is one line pointing at the comments in install.sh and .env. Shapes and status codes are taken from the handlers rather than from memory, and the auth behaviour was checked against a running server.	2026-08-29 03:45:27 +03:00