first commit

.gitignore

@@ -0,0 +1,6 @@
+data/
+web/build/
+web/.svelte-kit/
+web/node_modules/
+bin/
+*.log

AGENTS.md

@@ -0,0 +1,250 @@
+# pulse-lets-go — Telephone Load Balancer
+
+Балансировщик телефонной нагрузки на базе FreeSWITCH + NATS.
+Принимает метрики от нижестоящих АТС, вычисляет score готовности,
+возвращает лучшую ноду для следующего вызова через `/api/route`.
+
+## Стек
+
+| Компонент | Технология |
+|-----------|-----------|
+| Backend | Go (stdlib net/http или Chi, nats.go, golang-jwt, bcrypt) |
+| Frontend | SvelteKit + Tailwind + shadcn-svelte |
+| Auth | JWT access/refresh, bcrypt, роли: admin / viewer |
+| Шина | NATS — `pulse.metrics.<node_id>` |
+| Хранилище | JSON (`data/config.json`, `trunks.json`, `users.json`) + ASCII-лог метрик |
+| Деплой | systemd + единый бинарник, без Docker |
+
+## Модели данных
+
+### NATS message (node → balancer, каждые 5 сек)
+
+```json
+{
+  "node_id": "pbx-01",
+  "ts": 1719000000,
+  "status": "ok",
+  "active_calls": 42,
+  "max_calls": 250,
+  "idle_cpu": 35,
+  "load_avg": 0.85,
+  "call_failure_rate": 0.5
+}
+```
+
+`call_failure_rate`: 0.0..100.0 (проценты).
+
+### In-memory node state (engine)
+
+Все поля метрики + дополнительные:
+- `disabled` (bool) — ручное исключение админом
+- `disabled_reason` (string)
+
+## Scoring Engine
+
+### Lethal (score → -100, нода исключается)
+
+```
+status != "ok"
+stale > stale_threshold_sec (по умолчанию 20 сек)
+active_calls >= max_calls
+idle_cpu < idle_cpu_min (по умолчанию 5)
+disabled == true
+call_failure_rate > call_failure_rate_lethal (по умолчанию 15.0)
+```
+
+### Weighted score
+
+```
+call_score  = min(100, max(0, 100 - (active_calls / max_calls * 100)))
+load_score  = min(100, max(0, 100 - (load_avg * 50)))
+idle_score  = min(100, max(0, idle_cpu))
+fail_score  = min(100, max(0, 100 - call_failure_rate))
+
+score = call_score * 0.40 + load_score * 0.30 + idle_score * 0.20 + fail_score * 0.10
+```
+
+Веса и пороги конфигурируются в `config.json`.
+
+### Оптимизация
+
+`best_node_id` + `best_score` + `fallback_active` кэшируются, обновляются при каждой метрике.
+`/api/route` читает их за RLock, O(1).
+
+## HTTP API
+
+### Auth
+- `POST /api/auth/login` → JWT
+- Все эндпоинты (кроме login и `/api/monitoring/*`) требуют `Authorization: Bearer <jwt>`
+- `/api/monitoring/*` — API-key в заголовке `X-API-Key`
+
+### Core
+
+| Метод | Путь | Роль | Описание |
+|-------|------|------|----------|
+| `GET` | `/api/route?caller_id=X&dest=Y&ingress_trunk=Z` | – | Выбор ноды для звонка (без JWT) |
+
+Response (успех):
+```json
+{ "node_id": "pbx-03", "score": 88, "sip_gateway": "sip:pbx03.lan:5060" }
+```
+
+Response (fallback — все ноды unhealthy):
+```json
+{
+  "fallback": true,
+  "sip_gateway": "sip:operator.lan:5060",
+  "reason": "all_nodes_unhealthy",
+  "nodes": [...]
+}
+```
+
+Response (нет нод вообще):
+```json
+{ "error": "no_nodes_registered" }
+```
+
+### Nodes
+
+| Метод | Путь | Роль | Описание |
+|-------|------|------|----------|
+| `GET` | `/api/nodes` | admin/viewer | Список нод со score |
+| `GET` | `/api/nodes/:id/metrics` | admin/viewer | История метрик (ring buffer) |
+| `PUT` | `/api/nodes/:id/toggle` | admin | `{"disabled": true/false, "reason": "..."}` |
+
+### Trunks
+
+| Метод | Путь | Роль | Описание |
+|-------|------|------|----------|
+| `GET` | `/api/trunks` | admin | Все транки |
+| `GET` | `/api/trunks?type=ingress\|balance\|fallback` | admin | Фильтр по типу |
+| `POST` | `/api/trunks` | admin | Создать |
+| `PUT` | `/api/trunks/:id` | admin | Обновить |
+| `DELETE` | `/api/trunks/:id` | admin | Удалить |
+
+### Users (admin only)
+
+| Метод | Путь | Описание |
+|-------|------|----------|
+| `GET` | `/api/users` | Список |
+| `POST` | `/api/users` | Создать |
+| `PUT` | `/api/users/:id` | Обновить |
+| `DELETE` | `/api/users/:id` | Удалить |
+
+### Monitoring (API-key, не JWT)
+
+| Метод | Путь | Описание |
+|-------|------|----------|
+| `GET` | `/api/monitoring/zabbix` | JSON для Zabbix LLD + items |
+| `GET` | `/api/monitoring/prometheus` | text/plain метрики |
+
+### WebSocket
+
+| Метод | Путь | Описание |
+|-------|------|----------|
+| `WS` | `/ws/metrics` | Real-time метрики на фронт (JWT в query param) |
+
+## Терминология транков
+
+| Тип | Назначение | Сколько |
+|-----|-----------|---------|
+| `ingress` | Входящий транк (откуда звонки приходят) | 1..N |
+| `balance` | Транк назначения (куда балансятся, привязан к Node) | 1..N |
+| `fallback` | Резервный транк оператора (когда все balance score < 0) | ровно 1 |
+
+Модель транка:
+```json
+{
+  "id": "trk-001",
+  "name": "pbx-03 balance",
+  "type": "ingress|balance|fallback",
+  "node_id": "pbx-03",
+  "gateway": "sip:pbx03.lan:5060",
+  "codecs": ["PCMU", "PCMA"],
+  "context": "default",
+  "enabled": true,
+  "description": "",
+  "created_at": "...",
+  "updated_at": "..."
+}
+```
+
+## FreeSWITCH интеграция
+
+FS использует Lua скрипт в dialplan → `mod_curl` дёргает `/api/route` → получает JSON → парсит `sip_gateway` → bridge.
+
+```
+<extension name="route_call">
+  <condition field="destination_number" expression="^.*$">
+    <action application="lua" data="route.lua"/>
+  </condition>
+</extension>
+```
+
+route.lua: GET `/api/route?...` → если `fallback: true` идёт на fallback gateway, иначе на `sip_gateway`.
+
+## config.json
+
+```json
+{
+  "nats_url": "nats://localhost:4222",
+  "listen_addr": ":8080",
+  "jwt_secret": "auto-generated-on-first-run",
+  "monitoring_api_key": "auto-generated-on-first-run",
+  "stale_threshold_sec": 20,
+  "scoring": {
+    "idle_cpu_min": 5,
+    "call_failure_rate_lethal": 15.0,
+    "weights": {
+      "call_score": 0.40,
+      "load_score": 0.30,
+      "idle_score": 0.20,
+      "fail_score": 0.10
+    }
+  }
+}
+```
+
+## Структура проекта
+
+```
+pulse-lets-go/
+├── cmd/pulse-lets-go/main.go
+├── internal/
+│   ├── api/          — handlers: auth, nodes, trunks, users, monitoring, ws
+│   ├── engine/       — scorer + router (sync.RWMutex, best_node кэш)
+│   ├── nats/         — subscriber, in-memory node store
+│   ├── config/       — manager: чтение/атомарная запись JSON
+│   ├── models/       — все общие типы
+│   └── log/          — ASCII-metrics логгер + ротация
+├── data/             — JSON конфиги (gitignored)
+├── web/              — SvelteKit + shadcn-svelte + Tailwind
+│   ├── src/routes/
+│   │   ├── +layout.svelte
+│   │   ├── +page.svelte          # дашборд
+│   │   ├── login/+page.svelte
+│   │   ├── trunks/+page.svelte
+│   │   └── nodes/+page.svelte
+│   ├── src/lib/
+│   │   ├── components/
+│   │   └── api.ts
+│   ├── svelte.config.js
+│   ├── tailwind.config.js
+│   └── package.json
+├── go.mod
+├── Makefile
+└── AGENTS.md
+```
+
+## Порядок реализации
+
+1. `cmd/pulse-lets-go/main.go` + Go module + пустая структура internal
+2. `internal/models/` — все типы данных
+3. `internal/config/` — чтение/запись JSON, атомарное сохранение
+4. `internal/nats/` — подписка, in-memory store
+5. `internal/engine/` — scorer + router
+6. `internal/api/` — все хендлеры
+7. `internal/log/` — ASCII-логгер + ring buffer
+8. Web-фронт (SvelteKit)
+9. Makefile + systemd unit
+10. Тесты + graceful shutdown

Makefile

@@ -0,0 +1,142 @@
+# pulse-lets-go — Telephone Load Balancer
+# Сборка Go backend + SvelteKit фронта в единый бинарник.
+
+APP     := pulse-lets-go
+BINDIR  := bin
+WEB_DIR := web
+DATA_DIR := data
+
+.PHONY: all build build-go build-web clean run test install \
+        emulate emulate-normal emulate-overload emulate-cpu-low emulate-fail-high \
+        emulate-node-down emulate-stale emulate-chaos build-emulator
+
+all: build
+
+# Полная сборка: фронт + бекенд
+build: build-web build-go
+	@echo "✓ Сборка завершена: $(BINDIR)/$(APP)"
+
+# Сборка SvelteKit фронта
+build-web:
+	@echo "→ Сборка SvelteKit..."
+	cd $(WEB_DIR) && npm run build
+
+# Сборка Go бинарника
+build-go:
+	@mkdir -p $(BINDIR)
+	@echo "→ Сборка Go backend..."
+	go build -o $(BINDIR)/$(APP) ./cmd/$(APP)
+
+# Быстрая сборка только Go (без фронта)
+build-go-only:
+	@mkdir -p $(BINDIR)
+	go build -o $(BINDIR)/$(APP) ./cmd/$(APP)
+
+# Запуск в dev-режиме: Go backend на :8080, SvelteKit dev server на :5173
+run:
+	@echo "→ Запуск pulse-lets-go (dev)"
+	$(BINDIR)/$(APP) &
+	cd $(WEB_DIR) && npm run dev
+
+# Продакшн сборка с оптимизациями
+build-prod:
+	@mkdir -p $(BINDIR)
+	cd $(WEB_DIR) && npm run build
+	CGO_ENABLED=0 go build -ldflags="-s -w" -o $(BINDIR)/$(APP) ./cmd/$(APP)
+
+# Установка: копирует бинарник и статику в /usr/local
+install: build
+	@echo "→ Установка в /usr/local"
+	mkdir -p /usr/local/share/$(APP)/web
+	cp -r $(WEB_DIR)/build /usr/local/share/$(APP)/web/
+	cp $(BINDIR)/$(APP) /usr/local/bin/$(APP)
+	chmod +x /usr/local/bin/$(APP)
+	@echo "✓ Установлен в /usr/local/bin/$(APP)"
+
+# Установка systemd unit
+install-systemd:
+	@echo "→ Установка systemd unit"
+	cp deploy/$(APP).service /etc/systemd/system/
+	systemctl daemon-reload
+	@echo "✓ systemd unit установлен. Запуск: systemctl start $(APP)"
+
+# ============================================================
+# Эмулятор метрик
+# ============================================================
+
+# Сборка эмулятора
+build-emulator:
+	@mkdir -p $(BINDIR)
+	go build -o $(BINDIR)/emulator ./cmd/emulator
+
+# По умолчанию — normal
+emulate: emulate-normal
+
+# Все ноды здоровы, случайная загрузка
+emulate-normal: nats build-emulator
+	./$(BINDIR)/emulator --scenario normal
+
+# Последняя нода перегружена (active_calls=max_calls)
+emulate-overload: nats build-emulator
+	./$(BINDIR)/emulator --scenario overload
+
+# Последняя нода с низким idle_cpu (< 5)
+emulate-cpu-low: nats build-emulator
+	./$(BINDIR)/emulator --scenario cpu-low
+
+# Последняя нода с высоким call_failure_rate (> 15)
+emulate-fail-high: nats build-emulator
+	./$(BINDIR)/emulator --scenario fail-high
+
+# Последняя нода status="down"
+emulate-node-down: nats build-emulator
+	./$(BINDIR)/emulator --scenario node-down
+
+# Первая нода замолкает через 10 сек (stale)
+emulate-stale: nats build-emulator
+	./$(BINDIR)/emulator --scenario stale
+
+# Случайные lethal-состояния
+emulate-chaos: nats build-emulator
+	./$(BINDIR)/emulator --scenario chaos
+
+# ============================================================
+# NATS и запуск
+# ============================================================
+
+# Запуск NATS-сервера для разработки (в фоне)
+nats:
+	@echo "→ Запуск NATS на порту 4222..."
+	@if ! pgrep -x nats-server > /dev/null; then \
+		$(BINDIR)/nats-server -p 4222 -D &>/dev/null & \
+		disown; \
+		echo "✓ NATS запущен"; \
+	else \
+		echo "NATS уже запущен"; \
+	fi
+
+# Быстрый старт: NATS + pulse-lets-go
+start: nats
+	@echo "→ Запуск pulse-lets-go..."
+	$(BINDIR)/$(APP)
+
+# Очистка
+clean:
+	rm -rf $(BINDIR)
+	cd $(WEB_DIR) && rm -rf build .svelte-kit
+
+# Тесты
+test:
+	go test ./... -v -cover
+
+# Запуск тестов с race detector
+test-race:
+	go test ./... -race -v
+
+# Линтинг
+lint:
+	go vet ./...
+
+# Форматирование
+fmt:
+	go fmt ./...

cmd/emulator/main.go

@@ -0,0 +1,332 @@
+// Эмулятор метрик для pulse-lets-go.
+// Публикует метрики от эмулируемых нод в NATS, имитируя разные сценарии нагрузки.
+//
+//	Сценарии:
+//	  normal     — все ноды здоровы, случайная загрузка (проверка weighted score + best_node)
+//	  overload   — последняя нода перегружена (active_calls >= max_calls → lethal)
+//	  cpu-low    — последняя нода с низким idle_cpu (< 5 → lethal)
+//	  fail-high  — последняя нода с высоким call_failure_rate (> 15 → lethal)
+//	  node-down  — последняя нода status="down" (→ lethal)
+//	  stale      — первая нода перестаёт отправлять метрики через 10 сек (→ lethal)
+//	  chaos      — случайное чередование lethal-состояний у случайных нод
+package main
+
+import (
+	"encoding/json"
+	"flag"
+	"fmt"
+	"log"
+	"math/rand"
+	"os"
+	"os/signal"
+	"sync"
+	"syscall"
+	"time"
+
+	natsgo "github.com/nats-io/nats.go"
+)
+
+// --- Модель метрики ---
+
+type nodeMetric struct {
+	NodeID          string  `json:"node_id"`
+	TS              int64   `json:"ts"`
+	Status          string  `json:"status"`
+	ActiveCalls     int     `json:"active_calls"`
+	MaxCalls        int     `json:"max_calls"`
+	IdleCPU         float64 `json:"idle_cpu"`
+	LoadAvg         float64 `json:"load_avg"`
+	CallFailureRate float64 `json:"call_failure_rate"`
+}
+
+// --- Спецификация значения (фиксированное или случайный диапазон) ---
+
+type valueSpec struct {
+	fixed  float64
+	min    float64
+	max    float64
+	isRand bool
+}
+
+func fixed(v float64) valueSpec   { return valueSpec{fixed: v} }
+func rrange(min, max float64) valueSpec {
+	return valueSpec{min: min, max: max, isRand: true}
+}
+
+func (v valueSpec) get() float64 {
+	if v.isRand {
+		return v.min + rand.Float64()*(v.max-v.min)
+	}
+	return v.fixed
+}
+
+// --- Конфигурация ноды в эмуляторе ---
+
+type nodeSpec struct {
+	nodeID    string
+	status    valueSpec // строка: ok / down
+	calls     valueSpec
+	maxCalls  float64   // фиксированное
+	idleCPU   valueSpec
+	loadAvg   valueSpec
+	failRate  valueSpec
+}
+
+func (ns *nodeSpec) generate() nodeMetric {
+	return nodeMetric{
+		NodeID:          ns.nodeID,
+		TS:              time.Now().Unix(),
+		Status:          statusFromValue(ns.status.get()),
+		ActiveCalls:     int(ns.calls.get()),
+		MaxCalls:        int(ns.maxCalls),
+		IdleCPU:         ns.idleCPU.get(),
+		LoadAvg:         ns.loadAvg.get(),
+		CallFailureRate: ns.failRate.get(),
+	}
+}
+
+func statusFromValue(v float64) string {
+	if v < 0.5 {
+		return "down"
+	}
+	return "ok"
+}
+
+// --- Сценарии ---
+
+func scenarioNormal() []nodeSpec {
+	return []nodeSpec{
+		{
+			nodeID: "pbx-01", status: fixed(1),
+			calls: rrange(10, 100), maxCalls: 250,
+			idleCPU: rrange(40, 95), loadAvg: rrange(0.1, 1.0), failRate: rrange(0, 2),
+		},
+		{
+			nodeID: "pbx-02", status: fixed(1),
+			calls: rrange(50, 200), maxCalls: 250,
+			idleCPU: rrange(15, 45), loadAvg: rrange(0.5, 2.0), failRate: rrange(1, 8),
+		},
+		{
+			nodeID: "pbx-03", status: fixed(1),
+			calls: rrange(5, 60), maxCalls: 250,
+			idleCPU: rrange(60, 90), loadAvg: rrange(0.05, 0.5), failRate: rrange(0, 1),
+		},
+	}
+}
+
+func scenarioOverload() []nodeSpec {
+	specs := scenarioNormal()
+	// Последняя нода перегружена: active_calls = max_calls → lethal
+	specs[len(specs)-1].calls = fixed(250)
+	specs[len(specs)-1].idleCPU = fixed(10)
+	specs[len(specs)-1].loadAvg = fixed(5.0)
+	return specs
+}
+
+func scenarioCPULow() []nodeSpec {
+	specs := scenarioNormal()
+	specs[len(specs)-1].idleCPU = fixed(3) // < 5 → lethal
+	return specs
+}
+
+func scenarioFailHigh() []nodeSpec {
+	specs := scenarioNormal()
+	specs[len(specs)-1].failRate = fixed(20) // > 15 → lethal
+	return specs
+}
+
+func scenarioNodeDown() []nodeSpec {
+	specs := scenarioNormal()
+	specs[len(specs)-1].status = fixed(0) // status=down → lethal
+	return specs
+}
+
+func scenarioStale() []nodeSpec {
+	// Identical to normal — stale управляется логикой в main (пропуск отправки)
+	return scenarioNormal()
+}
+
+// --- Main ---
+
+func main() {
+	scenario := flag.String("scenario", "normal",
+		"Сценарий: normal | overload | cpu-low | fail-high | node-down | stale | chaos")
+	natsURL := flag.String("nats", "nats://localhost:4222", "NATS URL")
+	interval := flag.Duration("interval", 5*time.Second, "Интервал отправки метрик")
+	flag.Parse()
+
+	nc, err := natsgo.Connect(*natsURL, natsgo.MaxReconnects(-1))
+	if err != nil {
+		log.Fatalf("ошибка NATS: %v", err)
+	}
+	defer nc.Close()
+
+	var specs []nodeSpec
+	switch *scenario {
+	case "normal":
+		specs = scenarioNormal()
+	case "overload":
+		specs = scenarioOverload()
+	case "cpu-low":
+		specs = scenarioCPULow()
+	case "fail-high":
+		specs = scenarioFailHigh()
+	case "node-down":
+		specs = scenarioNodeDown()
+	case "stale":
+		specs = scenarioStale()
+	case "chaos":
+		specs = scenarioChaos()
+	default:
+		log.Fatalf("неизвестный сценарий: %s", *scenario)
+	}
+
+	log.Printf("[emulator] сценарий=%s, нод=%d, NATS=%s, интервал=%s",
+		*scenario, len(specs), *natsURL, *interval)
+
+	if *scenario == "chaos" {
+		runChaos(nc, specs, *interval)
+		return
+	}
+
+	if *scenario == "stale" {
+		runStale(nc, specs, *interval)
+		return
+	}
+
+	runNormal(nc, specs, *interval)
+}
+
+// runNormal — обычный цикл: все ноды шлют метрики каждые interval.
+func runNormal(nc *natsgo.Conn, specs []nodeSpec, interval time.Duration) {
+	log.Printf("[emulator] запущен, Ctrl+C для остановки")
+	ticker := time.NewTicker(interval)
+	defer ticker.Stop()
+
+	quit := make(chan os.Signal, 1)
+	signal.Notify(quit, syscall.SIGINT, syscall.SIGTERM)
+
+	// Первая отправка сразу
+	publishAll(nc, specs)
+
+	for {
+		select {
+		case <-ticker.C:
+			publishAll(nc, specs)
+		case <-quit:
+			log.Println("[emulator] остановлен")
+			return
+		}
+	}
+}
+
+// runStale — первая нода шлёт метрики только первые 10 секунд, потом замолкает.
+func runStale(nc *natsgo.Conn, specs []nodeSpec, interval time.Duration) {
+	log.Printf("[emulator] сценарий stale: нода %s замолкнет через 10 сек", specs[0].nodeID)
+
+	ticker := time.NewTicker(interval)
+	defer ticker.Stop()
+
+	quit := make(chan os.Signal, 1)
+	signal.Notify(quit, syscall.SIGINT, syscall.SIGTERM)
+
+	startTime := time.Now()
+	staleNodeID := specs[0].nodeID
+
+	publishAll(nc, specs)
+
+	for {
+		select {
+		case <-ticker.C:
+			elapsed := time.Since(startTime)
+			for _, spec := range specs {
+				if spec.nodeID == staleNodeID && elapsed > 10*time.Second {
+					continue // пропускаем stale-ноду
+				}
+				metric := spec.generate()
+				publish(nc, metric)
+			}
+		case <-quit:
+			log.Println("[emulator] остановлен")
+			return
+		}
+	}
+}
+
+// runChaos — случайно чередует lethal-состояния у случайных нод.
+func runChaos(nc *natsgo.Conn, specs []nodeSpec, interval time.Duration) {
+	log.Printf("[emulator] сценарий chaos: случайные lethal-состояния")
+
+	ticker := time.NewTicker(interval)
+	defer ticker.Stop()
+
+	quit := make(chan os.Signal, 1)
+	signal.Notify(quit, syscall.SIGINT, syscall.SIGTERM)
+
+	// Сохраняем оригинальные спецификации для восстановления
+	original := make([]nodeSpec, len(specs))
+	copy(original, specs)
+
+	var mu sync.Mutex
+
+	publishAll(nc, specs)
+
+	for {
+		select {
+		case <-ticker.C:
+			mu.Lock()
+			// Каждые 15-30 секунд случайно портим случайную ноду
+			if rand.Intn(4) == 0 { // ~25% шанс на каждом тике
+				idx := rand.Intn(len(specs))
+				kind := rand.Intn(5)
+				switch kind {
+				case 0:
+					specs[idx].status = fixed(0) // down
+				case 1:
+					specs[idx].calls = fixed(250) // overload
+				case 2:
+					specs[idx].idleCPU = fixed(2) // idle_cpu < 5
+				case 3:
+					specs[idx].failRate = fixed(25) // failure rate > 15
+				case 4:
+					// Восстановить оригинал
+					specs[idx] = original[idx]
+				}
+			}
+			publishAll(nc, specs)
+			mu.Unlock()
+		case <-quit:
+			log.Println("[emulator] остановлен")
+			return
+		}
+	}
+}
+
+func scenarioChaos() []nodeSpec {
+	// Начинаем с normal
+	return scenarioNormal()
+}
+
+// --- Helpers ---
+
+func publishAll(nc *natsgo.Conn, specs []nodeSpec) {
+	for _, spec := range specs {
+		metric := spec.generate()
+		publish(nc, metric)
+	}
+}
+
+func publish(nc *natsgo.Conn, m nodeMetric) {
+	subject := fmt.Sprintf("pulse.metrics.%s", m.NodeID)
+	data, err := json.Marshal(m)
+	if err != nil {
+		log.Printf("[emulator] ошибка сериализации %s: %v", m.NodeID, err)
+		return
+	}
+	if err := nc.Publish(subject, data); err != nil {
+		log.Printf("[emulator] ошибка публикации %s: %v", m.NodeID, err)
+		return
+	}
+	log.Printf("[emulator] → %s: calls=%d/%d idle=%.0f%% load=%.2f fail=%.1f%% status=%s",
+		m.NodeID, m.ActiveCalls, m.MaxCalls, m.IdleCPU, m.LoadAvg, m.CallFailureRate, m.Status)
+}

cmd/pulse-lets-go/main.go

@@ -0,0 +1,258 @@
+// pulse-lets-go — балансировщик телефонной нагрузки на базе FreeSWITCH + NATS.
+// Принимает метрики от нижестоящих АТС, вычисляет score готовности,
+// возвращает лучшую ноду для следующего вызова через /api/route.
+package main
+
+import (
+	"context"
+	"fmt"
+	"log"
+	"net/http"
+	"os"
+	"os/signal"
+	"path/filepath"
+	"strings"
+	"syscall"
+	"time"
+
+	"github.com/pulse-lets-go/internal/api"
+	"github.com/pulse-lets-go/internal/config"
+	"github.com/pulse-lets-go/internal/engine"
+	"github.com/pulse-lets-go/internal/esl"
+	filelog "github.com/pulse-lets-go/internal/log"
+	"github.com/pulse-lets-go/internal/nats"
+)
+
+func main() {
+	// Определяем рабочую директорию
+	exe, _ := os.Executable()
+	exeDir := filepath.Dir(exe)
+	dataDir := filepath.Join(exeDir, "data")
+
+	// Разрешаем переопределение через переменную окружения
+	if envDir := os.Getenv("PULSE_DATA_DIR"); envDir != "" {
+		dataDir = envDir
+	}
+
+	log.SetFlags(log.LstdFlags | log.Lshortfile)
+	log.Printf("[main] запуск pulse-lets-go, data_dir=%s", dataDir)
+
+	// 1. Инициализация конфиг-менеджера (создаёт data/ и дефолтные JSON при первом запуске)
+	cfgMgr, err := config.NewManager(dataDir)
+	if err != nil {
+		log.Fatalf("[main] ошибка инициализации конфигов: %v", err)
+	}
+
+	// 2. Чтение конфига
+	cfg, err := cfgMgr.ReadConfig()
+	if err != nil {
+		log.Fatalf("[main] ошибка чтения config.json: %v", err)
+	}
+
+	// 2.1 Валидация конфига
+	if err := cfg.Validate(); err != nil {
+		log.Fatalf("[main] ошибка валидации конфига:\n%v", err)
+	}
+
+	log.Printf("[main] NATS=%s, listen=%s, stale_threshold=%dсек, tls=%v, log=%s/%s",
+		cfg.NatsURL, cfg.ListenAddr, cfg.StaleThresholdSec, cfg.TLS.Enabled, cfg.Log.Level, cfg.Log.Format)
+
+	// 3. Engine
+	eng := engine.NewEngine(cfg)
+
+	// 4. ASCII логгер метрик
+	metricsLogger, err := filelog.NewLogger(dataDir)
+	if err != nil {
+		log.Fatalf("[main] ошибка создания логгера: %v", err)
+	}
+
+	// 5. NATS подписчик
+	sub, err := nats.NewSubscriber(cfg.NatsURL, cfg.NatsUser, cfg.NatsPassword, eng, metricsLogger)
+	if err != nil {
+		log.Fatalf("[main] ошибка NATS: %v", err)
+	}
+	defer sub.Close()
+
+	// 6. HTTP API
+	apiHandler := api.NewAPI(eng, cfgMgr, cfg.JWTSecret, cfg.MonitoringAPIKey, sub.IsConnected, cfg)
+	handler := apiHandler.Handler()
+
+	// 6.1 ESL-клиент (опционально — если сконфигурирован)
+	var eslClient *esl.Client
+	if cfg.ESL.Host != "" {
+		eslPassword := cfg.ESL.GetPassword()
+		eslClient = esl.NewClient(cfg.ESL.Host, cfg.ESL.Port, eslPassword)
+		apiHandler.SetESLClient(eslClient)
+
+		ctx, cancel := context.WithCancel(context.Background())
+		go func() {
+			eslClient.StartEventLoop(ctx, cfg.ESL.SofiaProfile,
+				func() {
+					trunks, err := cfgMgr.ReadTrunks()
+					if err != nil {
+						log.Printf("[esl] ошибка чтения транков для синхронизации: %v", err)
+						return
+					}
+					var specs []esl.GatewaySpec
+					for _, t := range trunks {
+						if t.Type == "ingress" && t.Enabled {
+							specs = append(specs, esl.GatewaySpec{
+								Name:  fmt.Sprintf("pulse-ingress-%s", t.ID),
+								Proxy: extractHostFromGateway(t.Gateway),
+							})
+						}
+					}
+					eslClient.GatewaySyncAll(cfg.ESL.SofiaProfile, specs)
+				},
+				func(eventName string, headers map[string]string, body string) {
+					log.Printf("[esl] событие: %s", eventName)
+				},
+			)
+			cancel()
+		}()
+	}
+
+	// ESL shutdown при завершении main
+	defer func() {
+		if eslClient != nil {
+			eslClient.Disconnect()
+		}
+	}()
+
+	// Подключаем раздачу SvelteKit статики, если директория существует
+	webDir := findWebDir(exeDir)
+	if webDir != "" {
+		log.Printf("[main] раздача SvelteKit статики из %s", webDir)
+		handler = withSPA(webDir, handler)
+	}
+
+	srv := &http.Server{
+		Addr:         cfg.ListenAddr,
+		Handler:      handler,
+		ReadTimeout:  10 * time.Second,
+		WriteTimeout: 10 * time.Second,
+		IdleTimeout:  60 * time.Second,
+	}
+
+	// 7. Запуск HTTP-сервера
+	go func() {
+		log.Printf("[main] HTTP сервер запущен на %s (tls=%v)", cfg.ListenAddr, cfg.TLS.Enabled)
+		log.Printf("[main] готов к работе:")
+		log.Printf("  GET  /api/health          — статус зависимостей")
+		log.Printf("  POST /api/auth/login       — аутентификация")
+		log.Printf("  GET  /api/route            — маршрутизация (FreeSWITCH)")
+		log.Printf("  GET  /api/nodes            — список нод")
+		log.Printf("  GET  /api/trunks           — управление транками")
+		log.Printf("  GET  /api/users            — управление пользователями")
+		log.Printf("  GET  /api/monitoring/zabbix  — Zabbix LLD + items")
+		log.Printf("  GET  /api/monitoring/prometheus — Prometheus метрики")
+		log.Printf("  WS   /ws/metrics           — real-time метрики на фронт")
+
+		var err error
+		if cfg.TLS.Enabled {
+			err = srv.ListenAndServeTLS(cfg.TLS.CertFile, cfg.TLS.KeyFile)
+		} else {
+			err = srv.ListenAndServe()
+		}
+		if err != nil && err != http.ErrServerClosed {
+			log.Fatalf("[main] ошибка HTTP сервера: %v", err)
+		}
+	}()
+
+	// 8. Graceful shutdown
+	quit := make(chan os.Signal, 1)
+	signal.Notify(quit, syscall.SIGINT, syscall.SIGTERM)
+	sig := <-quit
+	log.Printf("[main] получен сигнал %s, завершение работы...", sig)
+
+	ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
+	defer cancel()
+
+	if err := srv.Shutdown(ctx); err != nil {
+		log.Printf("[main] ошибка остановки HTTP сервера: %v", err)
+	}
+
+	sub.Close()
+	metricsLogger.Close()
+
+	log.Println("[main] pulse-lets-go остановлен")
+}
+
+// findWebDir ищет директорию со SvelteKit сборкой (web/build/).
+// Пробует по порядку: переменная окружения, рядом с бинарником, в корне проекта, CWD.
+func findWebDir(exeDir string) string {
+	candidates := []string{
+		os.Getenv("PULSE_WEB_DIR"),
+		filepath.Join(exeDir, "web", "build"),           // bin/web/build
+		filepath.Join(filepath.Dir(exeDir), "web", "build"), // ../web/build (корень проекта)
+		"web/build",                                     // ./web/build (CWD)
+	}
+	for _, d := range candidates {
+		if d == "" {
+			continue
+		}
+		if stat, err := os.Stat(d); err == nil && stat.IsDir() {
+			return d
+		}
+	}
+	return ""
+}
+
+// withSPA — middleware для раздачи SvelteKit SPA.
+// Запросы к /api/* и /ws/* проксируются в API handler.
+// Остальные запросы ищут статический файл в webDir; если файл не найден,
+// возвращается index.html (SPA fallback для клиентского роутинга).
+func withSPA(webDir string, apiHandler http.Handler) http.Handler {
+	fs := http.FileServer(http.Dir(webDir))
+
+	return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		path := r.URL.Path
+
+		// API и WebSocket запросы — передаём в API
+		if strings.HasPrefix(path, "/api/") || strings.HasPrefix(path, "/ws/") {
+			apiHandler.ServeHTTP(w, r)
+			return
+		}
+
+		// Пробуем отдать статический файл
+		filePath := filepath.Join(webDir, path)
+		info, err := os.Stat(filePath)
+
+		// Если файл существует и не является директорией — отдаём
+		if err == nil && !info.IsDir() {
+			fs.ServeHTTP(w, r)
+			return
+		}
+
+		// SPA fallback: index.html
+		indexPath := filepath.Join(webDir, "index.html")
+		if _, err := os.Stat(indexPath); err == nil {
+			http.ServeFile(w, r, indexPath)
+			return
+		}
+
+		// Если index.html тоже нет — 404
+		http.NotFound(w, r)
+	})
+}
+
+// extractHostFromGateway извлекает хост из SIP URI.
+// "sip:mts-gw.lan:5060" → "mts-gw.lan"
+func extractHostFromGateway(gateway string) string {
+	s := strings.TrimPrefix(gateway, "sip:")
+	s = strings.TrimPrefix(s, "sips:")
+	if idx := strings.LastIndex(s, ":"); idx > 0 {
+		port := s[idx+1:]
+		isNumeric := true
+		for _, c := range port {
+			if c < '0' || c > '9' {
+				isNumeric = false
+				break
+			}
+		}
+		if isNumeric {
+			s = s[:idx]
+		}
+	}
+	return s
+}

contrib/route.lua

@@ -0,0 +1,156 @@
+--[[
+ route.lua — запрашивает pulse-lets-go для маршрутизации вызова.
+ Телефонный балансировщик нагрузки на базе FreeSWITCH + NATS.
+
+ ┌─ Размещение ─────────────────────────────────────────────────────┐
+ │ /etc/freeswitch/scripts/route.lua                                │
+ │                                                                   │
+ │ ┌─ Использование в dialplan ────────────────────────────────────┐│
+ │ │ <extension name="route_call">                                 ││
+ │ │   <condition field="destination_number" expression="^.*$">    ││
+ │ │     <action application="lua" data="route.lua"/>              ││
+ │ │   </condition>                                                ││
+ │ │ </extension>                                                  ││
+ │ └───────────────────────────────────────────────────────────────┘│
+ │                                                                   │
+ │ ┌─ Переменные канала (опционально) ─────────────────────────────┐│
+ │ │ balancer_url    — URL pulse-lets-go (default: localhost:8080) ││
+ │ │ ingress_trunk   — ID входящего транка                         ││
+ │ └───────────────────────────────────────────────────────────────┘│
+ │                                                                   │
+ │ ┌─ Требования FreeSWITCH ───────────────────────────────────────┐│
+ │ │ mod_curl  — <load module="mod_curl"/> в modules.conf.xml      ││
+ │ │ cjson     — входит в стандартную поставку FS Lua              ││
+ │ └───────────────────────────────────────────────────────────────┘│
+ └───────────────────────────────────────────────────────────────────┘
+
+ Логика:
+   1. Извлечь caller_id + destination из переменных сессии
+   2. HTTP GET /api/route?caller_id=X&dest=Y&ingress_trunk=Z
+   3. Разобрать JSON-ответ
+   4. При fallback=true → bridge на fallback gateway (оператор)
+   5. При ошибке → кладём трубку с NORMAL_TEMPORARY_FAILURE
+   6. Нормальный маршрут → bridge на sip_gateway выбранной ноды
+]]--
+
+-- ===================================================================
+-- Конфигурация
+-- ===================================================================
+
+-- URL балансировщика (переопределяется через переменную канала)
+local BALANCER_URL = session:getVariable("balancer_url") or "http://localhost:8080"
+
+-- Таймаут HTTP-запроса в секундах (через параметр curl)
+local HTTP_TIMEOUT = tonumber(session:getVariable("route_timeout") or "3")
+
+-- JSON-парсер
+local cjson = require("cjson")
+
+-- API FreeSWITCH для вызова mod_curl
+local api = freeswitch.API()
+
+-- ===================================================================
+-- Вспомогательные функции
+-- ===================================================================
+
+-- Логирование с префиксом [route]
+local function log(level, msg)
+    freeswitch.consoleLog(level, "[route] " .. msg .. "\n")
+end
+
+-- Выполнить HTTP GET и вернуть тело ответа (без заголовков).
+-- mod_curl API возвращает сырой HTTP-ответ: заголовки + \r?\n\r?\n + тело.
+local function http_get(url)
+    local cmd = "curl " .. url
+    local raw = api:execute("curl", cmd)
+
+    if not raw or raw == "" then
+        return nil, "пустой ответ от curl"
+    end
+
+    -- Отделяем заголовки от тела
+    -- Ищем двойной перенос строки (CRLF или LF)
+    local body = raw:match("\r?\n\r?\n(.+)")
+    if not body then
+        -- Если нет заголовков — весь ответ это тело
+        return raw, nil
+    end
+    return body, nil
+end
+
+-- Безопасная отправка трубки с кодом причины
+local function safe_hangup(cause)
+    if session:ready() then
+        session:hangup(cause or "NORMAL_TEMPORARY_FAILURE")
+    end
+end
+
+-- ===================================================================
+-- Основная логика
+-- ===================================================================
+
+-- Извлекаем параметры вызова
+local caller_id = session:getVariable("caller_id_number") or ""
+local dest      = session:getVariable("destination_number") or ""
+local ing_trunk = session:getVariable("ingress_trunk") or ""
+
+-- Собираем URL
+local query = string.format("caller_id=%s&dest=%s", caller_id, dest)
+if ing_trunk ~= "" then
+    query = query .. "&ingress_trunk=" .. ing_trunk
+end
+local url = BALANCER_URL .. "/api/route?" .. query
+
+log("info", "запрос маршрута: " .. url)
+
+-- Запрашиваем маршрут у pulse-lets-go
+local body, curl_err = http_get(url)
+if not body then
+    log("err", "ошибка HTTP: " .. (curl_err or "unknown"))
+    safe_hangup()
+    return
+end
+
+-- Парсим JSON
+local ok, route = pcall(cjson.decode, body)
+if not ok or type(route) ~= "table" then
+    log("err", "ошибка парсинга JSON: " .. tostring(route))
+    safe_hangup()
+    return
+end
+
+-- ── Фолбэк (все ноды unhealthy) ──────────────────────────────────
+if route.fallback and route.sip_gateway then
+    log("info", string.format("FALLBACK → %s (причина: %s)",
+        route.sip_gateway, route.reason or "all_nodes_unhealthy"))
+
+    if route.nodes then
+        for _, n in ipairs(route.nodes) do
+            log("info", string.format("  %s: score=%d reason=%s",
+                n.id or "?", n.score or 0, n.reason or "-"))
+        end
+    end
+
+    session:execute("bridge", route.sip_gateway)
+    return
+end
+
+-- ── Ошибка API (нет зарегистрированных нод) ──────────────────────
+if route.error then
+    log("err", "ошибка балансировщика: " .. route.error)
+    safe_hangup()
+    return
+end
+
+-- ── Успешный маршрут ─────────────────────────────────────────────
+if route.sip_gateway then
+    log("info", string.format("ROUTE: %s score=%d → %s",
+        route.node_id or "?", route.score or 0, route.sip_gateway))
+
+    session:execute("bridge", route.sip_gateway)
+    return
+end
+
+-- ── Непредвиденная ситуация ──────────────────────────────────────
+log("err", "нет sip_gateway в ответе балансировщика")
+safe_hangup()

deploy/pulse-lets-go.service

@@ -0,0 +1,30 @@
+[Unit]
+Description=pulse-lets-go — Telephone Load Balancer
+Documentation=https://github.com/pulse-lets-go
+After=network.target nats.service
+Wants=nats.service
+
+[Service]
+Type=simple
+User=pulse
+Group=pulse
+ExecStart=/usr/local/bin/pulse-lets-go
+WorkingDirectory=/usr/local/share/pulse-lets-go
+Environment=PULSE_DATA_DIR=/etc/pulse-lets-go
+Restart=always
+RestartSec=5
+
+# Безопасность
+NoNewPrivileges=yes
+PrivateTmp=yes
+ProtectSystem=strict
+ProtectHome=yes
+ReadWritePaths=/etc/pulse-lets-go /var/log/pulse-lets-go
+
+# Логирование
+StandardOutput=journal
+StandardError=journal
+SyslogIdentifier=pulse-lets-go
+
+[Install]
+WantedBy=multi-user.target

go.mod

@@ -0,0 +1,17 @@
+module github.com/pulse-lets-go
+
+go 1.26.4
+
+require (
+	github.com/golang-jwt/jwt/v5 v5.3.1
+	github.com/gorilla/websocket v1.5.3
+	github.com/nats-io/nats.go v1.52.0
+	golang.org/x/crypto v0.53.0
+)
+
+require (
+	github.com/klauspost/compress v1.18.5 // indirect
+	github.com/nats-io/nkeys v0.4.15 // indirect
+	github.com/nats-io/nuid v1.0.1 // indirect
+	golang.org/x/sys v0.46.0 // indirect
+)

go.sum

@@ -0,0 +1,16 @@
+github.com/golang-jwt/jwt/v5 v5.3.1 h1:kYf81DTWFe7t+1VvL7eS+jKFVWaUnK9cB1qbwn63YCY=
+github.com/golang-jwt/jwt/v5 v5.3.1/go.mod h1:fxCRLWMO43lRc8nhHWY6LGqRcf+1gQWArsqaEUEa5bE=
+github.com/gorilla/websocket v1.5.3 h1:saDtZ6Pbx/0u+bgYQ3q96pZgCzfhKXGPqt7kZ72aNNg=
+github.com/gorilla/websocket v1.5.3/go.mod h1:YR8l580nyteQvAITg2hZ9XVh4b55+EU/adAjf1fMHhE=
+github.com/klauspost/compress v1.18.5 h1:/h1gH5Ce+VWNLSWqPzOVn6XBO+vJbCNGvjoaGBFW2IE=
+github.com/klauspost/compress v1.18.5/go.mod h1:cwPg85FWrGar70rWktvGQj8/hthj3wpl0PGDogxkrSQ=
+github.com/nats-io/nats.go v1.52.0 h1:n3avV4VBsCgsdwh71TppsTwtv+QdPs7ntSKM8qJLGsc=
+github.com/nats-io/nats.go v1.52.0/go.mod h1:26HypzazeOkyO3/mqd1zZd53STJN0EjCYF9Uy2ZOBno=
+github.com/nats-io/nkeys v0.4.15 h1:JACV5jRVO9V856KOapQ7x+EY8Jo3qw1vJt/9Jpwzkk4=
+github.com/nats-io/nkeys v0.4.15/go.mod h1:CpMchTXC9fxA5zrMo4KpySxNjiDVvr8ANOSZdiNfUrs=
+github.com/nats-io/nuid v1.0.1 h1:5iA8DT8V7q8WK2EScv2padNa/rTESc1KdnPw4TC2paw=
+github.com/nats-io/nuid v1.0.1/go.mod h1:19wcPz3Ph3q0Jbyiqsd0kePYG7A95tJPxeL+1OSON2c=
+golang.org/x/crypto v0.53.0 h1:QZ4Muo8THX6CizN2vPPd5fBGHyogrdK9fG4wLPFUsto=
+golang.org/x/crypto v0.53.0/go.mod h1:DNLU434OwVakk9PzuwV8w62mAJpRJL3vsgcfp4Qnsio=
+golang.org/x/sys v0.46.0 h1:noSf2Fq6F8DBgS+LysIkx7rIExoNHJsxOAtPp4rthXw=
+golang.org/x/sys v0.46.0/go.mod h1:4GL1E5IUh+htKOUEOaiffhrAeqysfVGipDYzABqnCmw=

internal/api/auth.go

@@ -0,0 +1,271 @@
+// Package api реализует HTTP API pulse-lets-go.
+package api
+
+import (
+	"context"
+	"encoding/json"
+	"log"
+	"net/http"
+	"strings"
+	"time"
+
+	"github.com/golang-jwt/jwt/v5"
+	"golang.org/x/crypto/bcrypt"
+
+	"github.com/pulse-lets-go/internal/models"
+)
+
+// JWT claims
+type claims struct {
+	UserID   string `json:"user_id"`
+	Username string `json:"username"`
+	Role     string `json:"role"`
+	jwt.RegisteredClaims
+}
+
+// contextKey — тип для ключей context.
+type contextKey string
+
+const (
+	userContextKey contextKey = "user"
+	refreshTokenKey contextKey = "refresh_token"
+)
+
+// UserInfo — информация о пользователе, извлекаемая из JWT.
+type UserInfo struct {
+	UserID   string
+	Username string
+	Role     string
+}
+
+const (
+	jwtExpiry        = 15 * time.Minute
+	refreshExpiry    = 24 * time.Hour
+)
+
+// generateJWT создаёт access+refresh токены.
+func (a *API) generateJWT(user *models.User) (*models.LoginResponse, error) {
+	now := time.Now()
+
+	// Access token
+	accessClaims := claims{
+		UserID:   user.ID,
+		Username: user.Username,
+		Role:     string(user.Role),
+		RegisteredClaims: jwt.RegisteredClaims{
+			ExpiresAt: jwt.NewNumericDate(now.Add(jwtExpiry)),
+			IssuedAt:  jwt.NewNumericDate(now),
+		},
+	}
+	accessToken, err := jwt.NewWithClaims(jwt.SigningMethodHS256, accessClaims).SignedString([]byte(a.jwtSecret))
+	if err != nil {
+		return nil, err
+	}
+
+	// Refresh token
+	refreshClaims := claims{
+		UserID:   user.ID,
+		Username: user.Username,
+		Role:     string(user.Role),
+		RegisteredClaims: jwt.RegisteredClaims{
+			ExpiresAt: jwt.NewNumericDate(now.Add(refreshExpiry)),
+			IssuedAt:  jwt.NewNumericDate(now),
+		},
+	}
+	refreshToken, err := jwt.NewWithClaims(jwt.SigningMethodHS256, refreshClaims).SignedString([]byte(a.jwtSecret))
+	if err != nil {
+		return nil, err
+	}
+
+	return &models.LoginResponse{
+		AccessToken:  accessToken,
+		RefreshToken: refreshToken,
+		ExpiresIn:    int64(jwtExpiry.Seconds()),
+	}, nil
+}
+
+// authMiddleware — проверяет JWT в заголовке Authorization.
+func (a *API) authMiddleware(next http.Handler) http.Handler {
+	return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		tokenStr := extractBearerToken(r)
+		if tokenStr == "" {
+			writeError(w, http.StatusUnauthorized, "требуется авторизация")
+			return
+		}
+
+		c := &claims{}
+		token, err := jwt.ParseWithClaims(tokenStr, c, func(token *jwt.Token) (interface{}, error) {
+			return []byte(a.jwtSecret), nil
+		})
+		if err != nil || !token.Valid {
+			writeError(w, http.StatusUnauthorized, "недействительный токен")
+			return
+		}
+
+		user := &UserInfo{
+			UserID:   c.UserID,
+			Username: c.Username,
+			Role:     c.Role,
+		}
+		ctx := context.WithValue(r.Context(), userContextKey, user)
+		next.ServeHTTP(w, r.WithContext(ctx))
+	})
+}
+
+// adminOnly — middleware проверки роли admin.
+func (a *API) adminOnly(next http.Handler) http.Handler {
+	return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		user := GetUserFromContext(r.Context())
+		if user == nil || user.Role != string(models.RoleAdmin) {
+			writeError(w, http.StatusForbidden, "требуется роль admin")
+			return
+		}
+		next.ServeHTTP(w, r)
+	})
+}
+
+// apiKeyMiddleware — проверяет API-key для monitoring endpoint.
+func (a *API) apiKeyMiddleware(next http.Handler) http.Handler {
+	return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		key := r.Header.Get("X-API-Key")
+		if key == "" || key != a.monitoringAPIKey {
+			writeError(w, http.StatusUnauthorized, "недействительный API-ключ")
+			return
+		}
+		next.ServeHTTP(w, r)
+	})
+}
+
+// handleLogin обрабатывает POST /api/auth/login.
+func (a *API) handleLogin(w http.ResponseWriter, r *http.Request) {
+	var req models.LoginRequest
+	if err := json.NewDecoder(r.Body).Decode(&req); err != nil {
+		writeError(w, http.StatusBadRequest, "некорректный JSON")
+		return
+	}
+
+	if req.Username == "" || req.Password == "" {
+		writeError(w, http.StatusBadRequest, "имя и пароль обязательны")
+		return
+	}
+
+	users, err := a.configManager.ReadUsers()
+	if err != nil {
+		log.Printf("[auth] ошибка чтения users.json: %v", err)
+		writeError(w, http.StatusInternalServerError, "ошибка сервера")
+		return
+	}
+
+	var found *models.User
+	for i := range users {
+		if users[i].Username == req.Username {
+			found = &users[i]
+			break
+		}
+	}
+
+	if found == nil {
+		writeError(w, http.StatusUnauthorized, "неверное имя или пароль")
+		return
+	}
+
+	// Если пароль не задан (плейсхолдер), разрешаем вход с паролем "admin"
+	if found.PasswordHash == "" {
+		if req.Password != "admin" {
+			writeError(w, http.StatusUnauthorized, "неверное имя или пароль")
+			return
+		}
+		// Хешируем пароль и сохраняем
+		hash, _ := bcrypt.GenerateFromPassword([]byte(req.Password), bcrypt.DefaultCost)
+		found.PasswordHash = string(hash)
+		a.configManager.SaveUsers(users)
+	} else {
+		if err := bcrypt.CompareHashAndPassword([]byte(found.PasswordHash), []byte(req.Password)); err != nil {
+			writeError(w, http.StatusUnauthorized, "неверное имя или пароль")
+			return
+		}
+	}
+
+	resp, err := a.generateJWT(found)
+	if err != nil {
+		log.Printf("[auth] ошибка генерации JWT: %v", err)
+		writeError(w, http.StatusInternalServerError, "ошибка сервера")
+		return
+	}
+
+	writeJSON(w, http.StatusOK, resp)
+}
+
+// handleRefresh выдаёт новый access токен по refresh токену.
+func (a *API) handleRefresh(w http.ResponseWriter, r *http.Request) {
+	tokenStr := extractBearerToken(r)
+	if tokenStr == "" {
+		// пробуем получить из query param (для WebSocket)
+		tokenStr = r.URL.Query().Get("token")
+	}
+	if tokenStr == "" {
+		writeError(w, http.StatusUnauthorized, "требуется токен")
+		return
+	}
+
+	c := &claims{}
+	token, err := jwt.ParseWithClaims(tokenStr, c, func(token *jwt.Token) (interface{}, error) {
+		return []byte(a.jwtSecret), nil
+	})
+	if err != nil || !token.Valid {
+		writeError(w, http.StatusUnauthorized, "недействительный refresh токен")
+		return
+	}
+
+	user := &models.User{
+		ID:       c.UserID,
+		Username: c.Username,
+		Role:     models.UserRole(c.Role),
+	}
+
+	resp, err := a.generateJWT(user)
+	if err != nil {
+		writeError(w, http.StatusInternalServerError, "ошибка сервера")
+		return
+	}
+
+	writeJSON(w, http.StatusOK, resp)
+}
+
+// --- Хелперы ---
+
+// extractBearerToken извлекает JWT из заголовка Authorization: Bearer <token>.
+func extractBearerToken(r *http.Request) string {
+	auth := r.Header.Get("Authorization")
+	if auth == "" {
+		return ""
+	}
+	parts := strings.SplitN(auth, " ", 2)
+	if len(parts) != 2 || !strings.EqualFold(parts[0], "bearer") {
+		return ""
+	}
+	return parts[1]
+}
+
+// GetUserFromContext извлекает UserInfo из контекста запроса.
+func GetUserFromContext(ctx context.Context) *UserInfo {
+	user, ok := ctx.Value(userContextKey).(*UserInfo)
+	if !ok {
+		return nil
+	}
+	return user
+}
+
+// writeJSON отправляет JSON-ответ.
+func writeJSON(w http.ResponseWriter, status int, v interface{}) {
+	w.Header().Set("Content-Type", "application/json")
+	w.WriteHeader(status)
+	json.NewEncoder(w).Encode(v)
+}
+
+// writeError отправляет JSON-ошибку.
+func writeError(w http.ResponseWriter, status int, msg string) {
+	w.Header().Set("Content-Type", "application/json")
+	w.WriteHeader(status)
+	json.NewEncoder(w).Encode(map[string]string{"error": msg})
+}

internal/api/health.go

@@ -0,0 +1,63 @@
+package api
+
+import (
+	"net/http"
+)
+
+// handleHealth — GET /api/health — возвращает статус всех зависимостей.
+func (a *API) handleHealth(w http.ResponseWriter, r *http.Request) {
+	stats := a.engine.GetHealthStats()
+
+	natsStatus := "disconnected"
+	if a.natsConnected != nil && a.natsConnected() {
+		natsStatus = "connected"
+	}
+
+	eslInfo := map[string]interface{}{"status": "disabled"}
+	if a.eslClient != nil {
+		eslStats := a.eslClient.GetStats()
+		eslInfo = map[string]interface{}{
+			"status":        eslStats.Status,
+			"host":          eslStats.Host,
+			"uptime_seconds": eslStats.UptimeSec,
+			"reconnects":    eslStats.Reconnects,
+			"gateway_ops":   eslStats.GatewayOps,
+			"events_recv":   eslStats.EventsRecv,
+		}
+	}
+
+	writeJSON(w, http.StatusOK, map[string]interface{}{
+		"status":  "ok",
+		"version": "1.0.0",
+		"connections": map[string]interface{}{
+			"nats": natsStatus,
+			"esl":  eslInfo,
+		},
+		"stats": stats,
+	})
+}
+
+// handleLiveness — GET /api/health/live — всегда 200, если процесс жив.
+func (a *API) handleLiveness(w http.ResponseWriter, r *http.Request) {
+	writeJSON(w, http.StatusOK, map[string]string{"status": "alive"})
+}
+
+// handleReadiness — GET /api/health/ready — 200 когда NATS подключён, метрики поступают.
+// ESL опционален — не требуется для готовности.
+func (a *API) handleReadiness(w http.ResponseWriter, r *http.Request) {
+	if a.natsConnected != nil && !a.natsConnected() {
+		writeJSON(w, http.StatusServiceUnavailable, map[string]string{
+			"status": "not_ready",
+			"reason": "nats_disconnected",
+		})
+		return
+	}
+	if !a.engine.HasRecentMetrics(60) {
+		writeJSON(w, http.StatusServiceUnavailable, map[string]string{
+			"status": "not_ready",
+			"reason": "no_recent_metrics",
+		})
+		return
+	}
+	writeJSON(w, http.StatusOK, map[string]string{"status": "ready"})
+}

internal/api/logging.go

@@ -0,0 +1,84 @@
+package api
+
+import (
+	"crypto/rand"
+	"encoding/hex"
+	"encoding/json"
+	"log"
+	"net/http"
+	"time"
+)
+
+// requestLoggingMiddleware логирует каждый HTTP-запрос с Request ID, методом, путём, статусом и длительностью.
+func requestLoggingMiddleware(logFormat string) func(http.Handler) http.Handler {
+	return func(next http.Handler) http.Handler {
+		return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+			// Не логируем health-check запросы и OPTIONS
+			if r.URL.Path == "/api/health/live" || r.URL.Path == "/api/health/ready" || r.Method == "OPTIONS" {
+				next.ServeHTTP(w, r)
+				return
+			}
+
+			reqID := generateRequestID()
+			r.Header.Set("X-Request-ID", reqID)
+			w.Header().Set("X-Request-ID", reqID)
+
+			start := time.Now()
+			lrw := &loggingResponseWriter{ResponseWriter: w, statusCode: http.StatusOK}
+
+			next.ServeHTTP(lrw, r)
+
+			duration := time.Since(start)
+
+			// Извлекаем пользователя из контекста (может быть nil)
+			userStr := "-"
+			if user := GetUserFromContext(r.Context()); user != nil {
+				userStr = user.Username
+			}
+
+			switch logFormat {
+			case "json":
+				entry := map[string]interface{}{
+					"ts":          start.UTC().Format(time.RFC3339),
+					"id":          reqID,
+					"method":      r.Method,
+					"path":        r.URL.Path,
+					"status":      lrw.statusCode,
+					"duration_ms": float64(duration.Microseconds()) / 1000.0,
+					"remote_addr": r.RemoteAddr,
+					"user":        userStr,
+				}
+				data, _ := json.Marshal(entry)
+				log.Printf("%s", string(data))
+			default:
+				log.Printf("[%s] %s %s %d %.2fms %s user=%s",
+					reqID, r.Method, r.URL.Path, lrw.statusCode,
+					float64(duration.Microseconds())/1000.0, r.RemoteAddr, userStr)
+			}
+		})
+	}
+}
+
+// generateRequestID генерирует случайный Request ID: req-XXXXXXXX.
+func generateRequestID() string {
+	b := make([]byte, 6)
+	if _, err := rand.Read(b); err != nil {
+		return "req-" + hex.EncodeToString([]byte{0, 0, 0, 0, 0, 0})
+	}
+	return "req-" + hex.EncodeToString(b)
+}
+
+// loggingResponseWriter оборачивает http.ResponseWriter для перехвата статус-кода.
+type loggingResponseWriter struct {
+	http.ResponseWriter
+	statusCode int
+}
+
+func (w *loggingResponseWriter) WriteHeader(code int) {
+	w.statusCode = code
+	w.ResponseWriter.WriteHeader(code)
+}
+
+func (w *loggingResponseWriter) Write(b []byte) (int, error) {
+	return w.ResponseWriter.Write(b)
+}

internal/api/monitoring.go

@@ -0,0 +1,78 @@
+package api
+
+import (
+	"fmt"
+	"net/http"
+	"strings"
+
+	"github.com/pulse-lets-go/internal/models"
+)
+
+// handleZabbix — GET /api/monitoring/zabbix — возвращает JSON для Zabbix LLD + items.
+func (a *API) handleZabbix(w http.ResponseWriter, r *http.Request) {
+	nodes := a.engine.GetAllNodes()
+
+	data := make([]models.ZabbixNode, 0, len(nodes))
+	for _, n := range nodes {
+		data = append(data, models.ZabbixNode{
+			NodeID:          n.NodeID,
+			Status:          n.Status,
+			ActiveCalls:     n.ActiveCalls,
+			MaxCalls:        n.MaxCalls,
+			IdleCPU:         n.IdleCPU,
+			LoadAvg:         n.LoadAvg,
+			CallFailureRate: n.CallFailureRate,
+			Score:           n.Score,
+			Disabled:        n.Disabled,
+			IsStale:         n.IsStale,
+			SecondsAgo:      n.SecondsAgo,
+		})
+	}
+
+	writeJSON(w, http.StatusOK, models.ZabbixResponse{Data: data})
+}
+
+// handlePrometheus — GET /api/monitoring/prometheus — text/plain метрики для Prometheus.
+func (a *API) handlePrometheus(w http.ResponseWriter, r *http.Request) {
+	nodes := a.engine.GetAllNodes()
+
+	var sb strings.Builder
+
+	for _, n := range nodes {
+		id := sanitizePromLabel(n.NodeID)
+
+		fmt.Fprintf(&sb, "pulse_node_active_calls{node=\"%s\"} %d\n", id, n.ActiveCalls)
+		fmt.Fprintf(&sb, "pulse_node_max_calls{node=\"%s\"} %d\n", id, n.MaxCalls)
+		fmt.Fprintf(&sb, "pulse_node_idle_cpu{node=\"%s\"} %.2f\n", id, n.IdleCPU)
+		fmt.Fprintf(&sb, "pulse_node_load_avg{node=\"%s\"} %.2f\n", id, n.LoadAvg)
+		fmt.Fprintf(&sb, "pulse_node_call_failure_rate{node=\"%s\"} %.2f\n", id, n.CallFailureRate)
+		fmt.Fprintf(&sb, "pulse_node_score{node=\"%s\"} %.2f\n", id, n.Score)
+		fmt.Fprintf(&sb, "pulse_node_seconds_ago{node=\"%s\"} %.2f\n", id, n.SecondsAgo)
+
+		disabledVal := 0
+		staleVal := 0
+		statusVal := 1 // ok
+		if n.Disabled {
+			disabledVal = 1
+		}
+		if n.IsStale {
+			staleVal = 1
+		}
+		if n.Status != "ok" {
+			statusVal = 0
+		}
+
+		fmt.Fprintf(&sb, "pulse_node_disabled{node=\"%s\"} %d\n", id, disabledVal)
+		fmt.Fprintf(&sb, "pulse_node_stale{node=\"%s\"} %d\n", id, staleVal)
+		fmt.Fprintf(&sb, "pulse_node_status_ok{node=\"%s\"} %d\n", id, statusVal)
+	}
+
+	w.Header().Set("Content-Type", "text/plain; charset=utf-8")
+	w.WriteHeader(http.StatusOK)
+	w.Write([]byte(sb.String()))
+}
+
+// sanitizePromLabel заменяет символы, недопустимые в Prometheus-лейблах.
+func sanitizePromLabel(s string) string {
+	return strings.ReplaceAll(strings.ReplaceAll(s, ".", "_"), "-", "_")
+}

internal/api/nodes.go

@@ -0,0 +1,52 @@
+package api
+
+import (
+	"net/http"
+
+	"github.com/pulse-lets-go/internal/models"
+)
+
+// handleGetNodes — GET /api/nodes — список всех нод с текущими score.
+func (a *API) handleGetNodes(w http.ResponseWriter, r *http.Request) {
+	nodes := a.engine.GetAllNodes()
+	writeJSON(w, http.StatusOK, nodes)
+}
+
+// handleGetNodeMetrics — GET /api/nodes/{id}/metrics — история метрик ноды из ring buffer.
+func (a *API) handleGetNodeMetrics(w http.ResponseWriter, r *http.Request) {
+	nodeID := r.PathValue("id")
+	if nodeID == "" {
+		writeError(w, http.StatusBadRequest, "не указан id ноды")
+		return
+	}
+
+	snapshots := a.engine.GetNodeHistory(nodeID)
+	writeJSON(w, http.StatusOK, map[string]interface{}{
+		"node_id":   nodeID,
+		"snapshots": snapshots,
+		"count":     len(snapshots),
+	})
+}
+
+// handleToggleNode — PUT /api/nodes/{id}/toggle — включение/выключение ноды.
+func (a *API) handleToggleNode(w http.ResponseWriter, r *http.Request) {
+	nodeID := r.PathValue("id")
+	if nodeID == "" {
+		writeError(w, http.StatusBadRequest, "не указан id ноды")
+		return
+	}
+
+	var req models.ToggleNodeRequest
+	if err := decodeJSON(r, &req); err != nil {
+		writeError(w, http.StatusBadRequest, "некорректный JSON")
+		return
+	}
+
+	if err := a.engine.ToggleNode(nodeID, req.Disabled, req.Reason); err != nil {
+		writeError(w, http.StatusNotFound, err.Error())
+		return
+	}
+
+	info, _ := a.engine.GetNodeInfo(nodeID)
+	writeJSON(w, http.StatusOK, info)
+}

internal/api/ratelimit.go

@@ -0,0 +1,109 @@
+package api
+
+import (
+	"net"
+	"net/http"
+	"sync"
+	"time"
+)
+
+// rateLimiter — in-memory token bucket rate limiter.
+type rateLimiter struct {
+	mu       sync.Mutex
+	buckets  map[string]*tokenBucket
+	rate     float64 // токенов в секунду
+	burst    int     // максимальный размер бакета
+	cleanupInterval time.Duration
+	lastCleanup    time.Time
+}
+
+type tokenBucket struct {
+	tokens   float64
+	lastSeen time.Time
+}
+
+// newRateLimiter создаёт rate limiter с заданными параметрами.
+func newRateLimiter(ratePerSec, burst int) *rateLimiter {
+	if burst <= 0 {
+		burst = ratePerSec
+	}
+	return &rateLimiter{
+		buckets:  make(map[string]*tokenBucket),
+		rate:     float64(ratePerSec),
+		burst:    burst,
+		cleanupInterval: 60 * time.Second,
+		lastCleanup:    time.Now(),
+	}
+}
+
+// allow проверяет, разрешён ли запрос для данного ключа.
+// Возвращает true если разрешён, false если превышен лимит.
+func (rl *rateLimiter) allow(key string) bool {
+	rl.mu.Lock()
+	defer rl.mu.Unlock()
+
+	now := time.Now()
+
+	// Периодическая очистка устаревших бакетов
+	if now.Sub(rl.lastCleanup) > rl.cleanupInterval {
+		for k, b := range rl.buckets {
+			if now.Sub(b.lastSeen) > rl.cleanupInterval {
+				delete(rl.buckets, k)
+			}
+		}
+		rl.lastCleanup = now
+	}
+
+	b, exists := rl.buckets[key]
+	if !exists {
+		// Новый бакет с полным запасом токенов
+		b = &tokenBucket{tokens: float64(rl.burst), lastSeen: now}
+		rl.buckets[key] = b
+		b.tokens-- // расходуем один токен
+		return true
+	}
+
+	// Пополняем токены
+	elapsed := now.Sub(b.lastSeen).Seconds()
+	b.tokens += elapsed * rl.rate
+	if b.tokens > float64(rl.burst) {
+		b.tokens = float64(rl.burst)
+	}
+	b.lastSeen = now
+
+	if b.tokens >= 1.0 {
+		b.tokens--
+		return true
+	}
+	return false
+}
+
+// rateLimitMiddleware создаёт middleware с rate limiting по IP.
+// Ключ — RemoteAddr (или X-Forwarded-For, если за проксей).
+func rateLimitMiddleware(limiter *rateLimiter) func(http.Handler) http.Handler {
+	return func(next http.Handler) http.Handler {
+		return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+			key := stripPort(r.RemoteAddr)
+			if fwd := r.Header.Get("X-Forwarded-For"); fwd != "" {
+				key = fwd
+			}
+
+			if !limiter.allow(key) {
+				w.Header().Set("Retry-After", "1")
+				writeError(w, http.StatusTooManyRequests, "слишком много запросов")
+				return
+			}
+
+			next.ServeHTTP(w, r)
+		})
+	}
+}
+
+// stripPort убирает порт из адреса (напр. "[::1]:58544" → "::1", "127.0.0.1:1234" → "127.0.0.1").
+func stripPort(addr string) string {
+	host, _, err := net.SplitHostPort(addr)
+	if err != nil {
+		return addr // нет порта
+	}
+	return host
+}

internal/api/route.go

@@ -0,0 +1,102 @@
+package api
+
+import (
+	"net/http"
+
+	"github.com/pulse-lets-go/internal/models"
+)
+
+// handleRoute — GET /api/route — главный эндпоинт маршрутизации вызова.
+func (a *API) handleRoute(w http.ResponseWriter, r *http.Request) {
+	a.engine.IncrementRouteRequests()
+
+	nodeID, score, fallback := a.engine.GetBestNode()
+
+	// Нет зарегистрированных нод
+	if nodeID == "" {
+		writeJSON(w, http.StatusServiceUnavailable, models.RouteResponse{
+			Error: "no_nodes_registered",
+		})
+		return
+	}
+
+	// Все ноды unhealthy — fallback
+	if fallback || score < 0 {
+		fallbackGW, _ := a.findFallbackGateway()
+		nodes := a.getRouteNodeInfo()
+
+		writeJSON(w, http.StatusOK, models.RouteResponse{
+			Fallback:   true,
+			SIPGateway:  fallbackGW,
+			Reason:     "all_nodes_unhealthy",
+			Nodes:      nodes,
+		})
+		return
+	}
+
+	// Нормальный маршрут
+	gw, ok := a.findBalanceGateway(nodeID)
+	if !ok {
+		writeError(w, http.StatusInternalServerError, "gateway не найден для ноды")
+		return
+	}
+
+	writeJSON(w, http.StatusOK, models.RouteResponse{
+		NodeID:     nodeID,
+		Score:      score,
+		SIPGateway: gw,
+	})
+}
+
+// findBalanceGateway ищет gateway для balance-транка, привязанного к nodeID.
+func (a *API) findBalanceGateway(nodeID string) (string, bool) {
+	trunks, err := a.configManager.ReadTrunks()
+	if err != nil {
+		return "", false
+	}
+	for _, t := range trunks {
+		if t.Type == models.TrunkBalance && t.NodeID == nodeID && t.Enabled {
+			return t.Gateway, true
+		}
+	}
+	return "", false
+}
+
+// findFallbackGateway ищет gateway для fallback-транка.
+func (a *API) findFallbackGateway() (string, bool) {
+	trunks, err := a.configManager.ReadTrunks()
+	if err != nil {
+		return "", false
+	}
+	for _, t := range trunks {
+		if t.Type == models.TrunkFallback && t.Enabled {
+			return t.Gateway, true
+		}
+	}
+	return "", false
+}
+
+// getRouteNodeInfo возвращает список нод с их скорами для ответа маршрутизации.
+func (a *API) getRouteNodeInfo() []models.RouteNodeInfo {
+	nodes := a.engine.GetAllNodes()
+	result := make([]models.RouteNodeInfo, 0, len(nodes))
+	for _, n := range nodes {
+		info := models.RouteNodeInfo{
+			ID:     n.NodeID,
+			Score:  n.Score,
+			Reason: n.LethalReason,
+			Status: n.Status,
+		}
+		if n.Disabled {
+			info.Status = "disabled"
+		} else if n.IsStale {
+			info.Status = "stale"
+		} else if n.Score < 0 {
+			info.Status = "unhealthy"
+		} else {
+			info.Status = "healthy"
+		}
+		result = append(result, info)
+	}
+	return result
+}

internal/api/router.go

@@ -0,0 +1,137 @@
+package api
+
+import (
+	"encoding/json"
+	"fmt"
+	"net/http"
+
+	"github.com/pulse-lets-go/internal/config"
+	"github.com/pulse-lets-go/internal/engine"
+	"github.com/pulse-lets-go/internal/esl"
+)
+
+// API — главная структура HTTP API, агрегирует все зависимости.
+type API struct {
+	engine           *engine.Engine
+	configManager    *config.Manager
+	jwtSecret        string
+	monitoringAPIKey string
+	wsHub            *wsHub
+	natsConnected    func() bool   // колбэк для проверки NATS-статуса (health)
+	eslClient        *esl.Client   // ESL-клиент (nil если не сконфигурирован)
+	logFormat        string
+	routeLimiter     *rateLimiter
+	apiLimiter       *rateLimiter
+}
+
+// NewAPI создаёт новый HTTP API с заданными зависимостями.
+func NewAPI(eng *engine.Engine, cfgMgr *config.Manager, jwtSecret, monitoringAPIKey string, natsFn func() bool, cfg *config.Config) *API {
+	a := &API{
+		engine:           eng,
+		configManager:    cfgMgr,
+		jwtSecret:        jwtSecret,
+		monitoringAPIKey: monitoringAPIKey,
+		wsHub:            newWSHub(),
+		natsConnected:    natsFn,
+		logFormat:        cfg.Log.Format,
+	}
+	if cfg.RateLimit.Enabled {
+		a.routeLimiter = newRateLimiter(cfg.RateLimit.RoutePerSec, cfg.RateLimit.RoutePerSec)
+		a.apiLimiter = newRateLimiter(cfg.RateLimit.APIPerSec, cfg.RateLimit.APIPerSec)
+	}
+	return a
+}
+
+// SetESLClient устанавливает ESL-клиент (вызывается после инициализации ESL).
+func (a *API) SetESLClient(client *esl.Client) {
+	a.eslClient = client
+}
+
+// Handler возвращает http.Handler со всеми зарегистрированными маршрутами.
+func (a *API) Handler() http.Handler {
+	mux := http.NewServeMux()
+
+	// --- Health endpoints (без авторизации) ---
+
+	mux.HandleFunc("GET /api/health", a.handleHealth)
+	mux.HandleFunc("GET /api/health/live", a.handleLiveness)
+	mux.HandleFunc("GET /api/health/ready", a.handleReadiness)
+
+	// --- Публичные маршруты (без авторизации) ---
+
+	mux.HandleFunc("POST /api/auth/login", a.handleLogin)
+	mux.HandleFunc("POST /api/auth/refresh", a.handleRefresh)
+	mux.HandleFunc("GET /api/route", a.handleRoute)
+	mux.HandleFunc("GET /ws/metrics", a.handleWS)
+
+	// Monitoring с API-key (без JWT)
+	mux.Handle("GET /api/monitoring/zabbix", a.apiKeyMiddleware(http.HandlerFunc(a.handleZabbix)))
+	mux.Handle("GET /api/monitoring/prometheus", a.apiKeyMiddleware(http.HandlerFunc(a.handlePrometheus)))
+
+	// --- Админка: Nodes (admin + viewer) ---
+
+	mux.Handle("GET /api/nodes", a.authMiddleware(http.HandlerFunc(a.handleGetNodes)))
+	mux.Handle("GET /api/nodes/{id}/metrics", a.authMiddleware(http.HandlerFunc(a.handleGetNodeMetrics)))
+	mux.Handle("PUT /api/nodes/{id}/toggle", a.authMiddleware(a.adminOnly(http.HandlerFunc(a.handleToggleNode))))
+
+	// --- Админка: Trunks (admin only) ---
+
+	mux.Handle("GET /api/trunks", a.authMiddleware(a.adminOnly(http.HandlerFunc(a.handleGetTrunks))))
+	mux.Handle("POST /api/trunks", a.authMiddleware(a.adminOnly(http.HandlerFunc(a.handleCreateTrunk))))
+	mux.Handle("PUT /api/trunks/{id}", a.authMiddleware(a.adminOnly(http.HandlerFunc(a.handleUpdateTrunk))))
+	mux.Handle("DELETE /api/trunks/{id}", a.authMiddleware(a.adminOnly(http.HandlerFunc(a.handleDeleteTrunk))))
+
+	// --- Админка: Users (admin only) ---
+
+	mux.Handle("GET /api/users", a.authMiddleware(a.adminOnly(http.HandlerFunc(a.handleGetUsers))))
+	mux.Handle("POST /api/users", a.authMiddleware(a.adminOnly(http.HandlerFunc(a.handleCreateUser))))
+	mux.Handle("PUT /api/users/{id}", a.authMiddleware(a.adminOnly(http.HandlerFunc(a.handleUpdateUser))))
+	mux.Handle("DELETE /api/users/{id}", a.authMiddleware(a.adminOnly(http.HandlerFunc(a.handleDeleteUser))))
+
+	// Логирование + CORS (навешиваем после mux)
+	var wrapped http.Handler = mux
+	wrapped = requestLoggingMiddleware(a.logFormat)(wrapped)
+
+	// Rate limiting
+	if a.routeLimiter != nil && a.apiLimiter != nil {
+		handlerBeforeRL := wrapped
+		wrapped = http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+			if r.URL.Path == "/api/route" {
+				rateLimitMiddleware(a.routeLimiter)(handlerBeforeRL).ServeHTTP(w, r)
+				return
+			}
+			if len(r.URL.Path) > 5 && r.URL.Path[:5] == "/api/" {
+				rateLimitMiddleware(a.apiLimiter)(handlerBeforeRL).ServeHTTP(w, r)
+				return
+			}
+			handlerBeforeRL.ServeHTTP(w, r)
+		})
+	}
+
+	return corsMiddleware(wrapped)
+}
+
+// corsMiddleware добавляет CORS-заголовки.
+func corsMiddleware(next http.Handler) http.Handler {
+	return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		w.Header().Set("Access-Control-Allow-Origin", "*")
+		w.Header().Set("Access-Control-Allow-Methods", "GET, POST, PUT, DELETE, OPTIONS")
+		w.Header().Set("Access-Control-Allow-Headers", "Content-Type, Authorization, X-API-Key")
+
+		if r.Method == http.MethodOptions {
+			w.WriteHeader(http.StatusNoContent)
+			return
+		}
+
+		next.ServeHTTP(w, r)
+	})
+}
+
+// decodeJSON декодирует тело запроса в структуру v.
+func decodeJSON(r *http.Request, v interface{}) error {
+	defer r.Body.Close()
+	if err := json.NewDecoder(r.Body).Decode(v); err != nil {
+		return fmt.Errorf("декодирование JSON: %w", err)
+	}
+	return nil
+}

internal/api/trunks.go

@@ -0,0 +1,306 @@
+package api
+
+import (
+	"fmt"
+	"log"
+	"net/http"
+	"sort"
+	"strings"
+	"time"
+
+	"github.com/pulse-lets-go/internal/config"
+	"github.com/pulse-lets-go/internal/models"
+)
+
+// handleGetTrunks — GET /api/trunks — список всех транков с опциональным фильтром.
+func (a *API) handleGetTrunks(w http.ResponseWriter, r *http.Request) {
+	trunks, err := a.configManager.ReadTrunks()
+	if err != nil {
+		writeError(w, http.StatusInternalServerError, "ошибка чтения транков")
+		return
+	}
+
+	// Фильтр по типу
+	typeFilter := r.URL.Query().Get("type")
+	if typeFilter != "" {
+		filtered := make([]models.Trunk, 0)
+		for _, t := range trunks {
+			if string(t.Type) == typeFilter {
+				filtered = append(filtered, t)
+			}
+		}
+		trunks = filtered
+	}
+
+	// Сортировка по created_at
+	sort.Slice(trunks, func(i, j int) bool {
+		return trunks[i].CreatedAt.Before(trunks[j].CreatedAt)
+	})
+
+	writeJSON(w, http.StatusOK, trunks)
+}
+
+// handleCreateTrunk — POST /api/trunks — создание нового транка.
+func (a *API) handleCreateTrunk(w http.ResponseWriter, r *http.Request) {
+	var req models.CreateTrunkRequest
+	if err := decodeJSON(r, &req); err != nil {
+		writeError(w, http.StatusBadRequest, "некорректный JSON")
+		return
+	}
+
+	if err := validateTrunk(req.Name, req.Type, req.Gateway); err != nil {
+		writeError(w, http.StatusBadRequest, err.Error())
+		return
+	}
+
+	// Проверяем: fallback может быть только один
+	trunks, err := a.configManager.ReadTrunks()
+	if err != nil {
+		writeError(w, http.StatusInternalServerError, "ошибка чтения транков")
+		return
+	}
+	if req.Type == models.TrunkFallback {
+		for _, t := range trunks {
+			if t.Type == models.TrunkFallback {
+				writeError(w, http.StatusConflict, "fallback-транк уже существует (должен быть ровно 1)")
+				return
+			}
+		}
+	}
+
+	now := time.Now().UTC()
+	trunk := models.Trunk{
+		ID:          generateID("trk"),
+		Name:        req.Name,
+		Type:        req.Type,
+		NodeID:      req.NodeID,
+		Gateway:     req.Gateway,
+		Codecs:      req.Codecs,
+		Context:     req.Context,
+		Enabled:     req.Enabled,
+		Description: req.Description,
+		CreatedAt:   now,
+		UpdatedAt:   now,
+	}
+
+	trunks = append(trunks, trunk)
+	if err := a.configManager.SaveTrunks(trunks); err != nil {
+		writeError(w, http.StatusInternalServerError, "ошибка сохранения транка")
+		return
+	}
+
+	// ESL push: создаём gateway на FS для ingress-транка
+	a.eslPushGatewayAdd(trunk)
+
+	writeJSON(w, http.StatusCreated, trunk)
+}
+
+// handleUpdateTrunk — PUT /api/trunks/{id} — обновление транка.
+func (a *API) handleUpdateTrunk(w http.ResponseWriter, r *http.Request) {
+	trunkID := r.PathValue("id")
+	if trunkID == "" {
+		writeError(w, http.StatusBadRequest, "не указан id транка")
+		return
+	}
+
+	var req models.UpdateTrunkRequest
+	if err := decodeJSON(r, &req); err != nil {
+		writeError(w, http.StatusBadRequest, "некорректный JSON")
+		return
+	}
+
+	trunks, err := a.configManager.ReadTrunks()
+	if err != nil {
+		writeError(w, http.StatusInternalServerError, "ошибка чтения транков")
+		return
+	}
+
+	idx := findTrunkIndex(trunks, trunkID)
+	if idx < 0 {
+		writeError(w, http.StatusNotFound, "транк не найден")
+		return
+	}
+
+	// Применяем частичные обновления
+	t := &trunks[idx]
+	if req.Name != nil {
+		t.Name = *req.Name
+	}
+	if req.Type != nil {
+		// Проверка fallback-уникальности
+		if *req.Type == models.TrunkFallback && t.Type != models.TrunkFallback {
+			for _, other := range trunks {
+				if other.Type == models.TrunkFallback && other.ID != trunkID {
+					writeError(w, http.StatusConflict, "fallback-транк уже существует")
+					return
+				}
+			}
+		}
+		t.Type = *req.Type
+	}
+	if req.NodeID != nil {
+		t.NodeID = *req.NodeID
+	}
+	if req.Gateway != nil {
+		t.Gateway = *req.Gateway
+	}
+	if req.Codecs != nil {
+		t.Codecs = req.Codecs
+	}
+	if req.Context != nil {
+		t.Context = *req.Context
+	}
+	if req.Enabled != nil {
+		t.Enabled = *req.Enabled
+	}
+	if req.Description != nil {
+		t.Description = *req.Description
+	}
+	t.UpdatedAt = time.Now().UTC()
+
+	if err := a.configManager.SaveTrunks(trunks); err != nil {
+		writeError(w, http.StatusInternalServerError, "ошибка сохранения транка")
+		return
+	}
+
+	// ESL push: обновляем gateway на FS
+	a.eslPushGatewayUpdate(*t)
+
+	writeJSON(w, http.StatusOK, t)
+}
+
+// handleDeleteTrunk — DELETE /api/trunks/{id} — удаление транка.
+func (a *API) handleDeleteTrunk(w http.ResponseWriter, r *http.Request) {
+	trunkID := r.PathValue("id")
+	if trunkID == "" {
+		writeError(w, http.StatusBadRequest, "не указан id транка")
+		return
+	}
+
+	trunks, err := a.configManager.ReadTrunks()
+	if err != nil {
+		writeError(w, http.StatusInternalServerError, "ошибка чтения транков")
+		return
+	}
+
+	idx := findTrunkIndex(trunks, trunkID)
+	if idx < 0 {
+		writeError(w, http.StatusNotFound, "транк не найден")
+		return
+	}
+
+	deletedTrunk := trunks[idx]
+	trunks = append(trunks[:idx], trunks[idx+1:]...)
+
+	// ESL push: удаляем gateway на FS
+	a.eslPushGatewayDelete(deletedTrunk)
+
+	if err := a.configManager.SaveTrunks(trunks); err != nil {
+		writeError(w, http.StatusInternalServerError, "ошибка сохранения транков")
+		return
+	}
+
+	writeJSON(w, http.StatusNoContent, nil)
+}
+
+// --- helpers ---
+
+func validateTrunk(name string, trunkType models.TrunkType, gateway string) error {
+	if name == "" {
+		return fmt.Errorf("имя транка обязательно")
+	}
+	if gateway == "" {
+		return fmt.Errorf("gateway обязателен")
+	}
+	switch trunkType {
+	case models.TrunkIngress, models.TrunkBalance, models.TrunkFallback:
+		break
+	default:
+		return fmt.Errorf("некорректный тип транка: %s", trunkType)
+	}
+	return nil
+}
+
+func findTrunkIndex(trunks []models.Trunk, id string) int {
+	for i := range trunks {
+		if trunks[i].ID == id {
+			return i
+		}
+	}
+	return -1
+}
+
+// --- ESL push helpers ---
+
+// eslPushGatewayAdd создаёт gateway на FS для ingress-транка.
+func (a *API) eslPushGatewayAdd(trunk models.Trunk) {
+	if a.eslClient == nil || !a.eslClient.IsConnected() || trunk.Type != models.TrunkIngress {
+		return
+	}
+	profile, name, proxy := a.gatewayParams(trunk)
+	if err := a.eslClient.GatewayAdd(profile, name, proxy); err != nil {
+		log.Printf("[esl] GatewayAdd %s: %v", name, err)
+	}
+}
+
+// eslPushGatewayUpdate обновляет gateway на FS (удаляет старый + создаёт новый).
+func (a *API) eslPushGatewayUpdate(trunk models.Trunk) {
+	if a.eslClient == nil || !a.eslClient.IsConnected() || trunk.Type != models.TrunkIngress {
+		return
+	}
+	profile, name, proxy := a.gatewayParams(trunk)
+	_ = a.eslClient.GatewayDelete(profile, name) // игнорируем ошибку — может не существовать
+	if err := a.eslClient.GatewayAdd(profile, name, proxy); err != nil {
+		log.Printf("[esl] GatewayUpdate %s: %v", name, err)
+	}
+}
+
+// eslPushGatewayDelete удаляет gateway на FS для ingress-транка.
+func (a *API) eslPushGatewayDelete(trunk models.Trunk) {
+	if a.eslClient == nil || !a.eslClient.IsConnected() || trunk.Type != models.TrunkIngress {
+		return
+	}
+	profile, name, _ := a.gatewayParams(trunk)
+	if err := a.eslClient.GatewayDelete(profile, name); err != nil {
+		log.Printf("[esl] GatewayDelete %s: %v", name, err)
+	}
+}
+
+// gatewayParams возвращает параметры для создания FS gateway на основе транка.
+func (a *API) gatewayParams(trunk models.Trunk) (profile, name, proxy string) {
+	profile = a.readConfig().ESL.SofiaProfile
+	name = fmt.Sprintf("pulse-ingress-%s", trunk.ID)
+	proxy = extractHost(trunk.Gateway)
+	return
+}
+
+// extractHost извлекает хост из SIP URI.
+// "sip:mts-gw.lan:5060" → "mts-gw.lan"
+func extractHost(gateway string) string {
+	s := strings.TrimPrefix(gateway, "sip:")
+	s = strings.TrimPrefix(s, "sips:")
+	if idx := strings.LastIndex(s, ":"); idx > 0 {
+		// Проверяем, порт ли это (все цифры после двоеточия)
+		port := s[idx+1:]
+		isNumeric := true
+		for _, c := range port {
+			if c < '0' || c > '9' {
+				isNumeric = false
+				break
+			}
+		}
+		if isNumeric {
+			s = s[:idx]
+		}
+	}
+	return s
+}
+
+// readConfig возвращает текущий конфиг (для получения esl.sofia_profile).
+func (a *API) readConfig() *config.Config {
+	cfg, _ := a.configManager.ReadConfig()
+	if cfg == nil {
+		return &config.Config{ESL: config.ESLConfig{SofiaProfile: "external"}}
+	}
+	return cfg
+}

internal/api/users.go

@@ -0,0 +1,241 @@
+package api
+
+import (
+	"crypto/rand"
+	"encoding/hex"
+	"fmt"
+	"net/http"
+	"time"
+
+	"github.com/pulse-lets-go/internal/models"
+	"golang.org/x/crypto/bcrypt"
+)
+
+// handleGetUsers — GET /api/users — список пользователей.
+func (a *API) handleGetUsers(w http.ResponseWriter, r *http.Request) {
+	users, err := a.configManager.ReadUsers()
+	if err != nil {
+		writeError(w, http.StatusInternalServerError, "ошибка чтения пользователей")
+		return
+	}
+
+	// Не возвращаем хэши паролей
+	type safeUser struct {
+		ID        string          `json:"id"`
+		Username  string          `json:"username"`
+		Role      models.UserRole `json:"role"`
+		CreatedAt time.Time       `json:"created_at"`
+		UpdatedAt time.Time       `json:"updated_at"`
+	}
+	result := make([]safeUser, len(users))
+	for i, u := range users {
+		result[i] = safeUser{
+			ID:        u.ID,
+			Username:  u.Username,
+			Role:      u.Role,
+			CreatedAt: u.CreatedAt,
+			UpdatedAt: u.UpdatedAt,
+		}
+	}
+
+	writeJSON(w, http.StatusOK, result)
+}
+
+// handleCreateUser — POST /api/users — создание пользователя.
+func (a *API) handleCreateUser(w http.ResponseWriter, r *http.Request) {
+	var req models.CreateUserRequest
+	if err := decodeJSON(r, &req); err != nil {
+		writeError(w, http.StatusBadRequest, "некорректный JSON")
+		return
+	}
+
+	if req.Username == "" || req.Password == "" {
+		writeError(w, http.StatusBadRequest, "имя и пароль обязательны")
+		return
+	}
+	if req.Role != models.RoleAdmin && req.Role != models.RoleViewer {
+		writeError(w, http.StatusBadRequest, "роль должна быть admin или viewer")
+		return
+	}
+
+	users, err := a.configManager.ReadUsers()
+	if err != nil {
+		writeError(w, http.StatusInternalServerError, "ошибка чтения пользователей")
+		return
+	}
+
+	// Проверка уникальности имени
+	for _, u := range users {
+		if u.Username == req.Username {
+			writeError(w, http.StatusConflict, "пользователь с таким именем уже существует")
+			return
+		}
+	}
+
+	hash, err := bcrypt.GenerateFromPassword([]byte(req.Password), bcrypt.DefaultCost)
+	if err != nil {
+		writeError(w, http.StatusInternalServerError, "ошибка хеширования пароля")
+		return
+	}
+
+	now := time.Now().UTC()
+	user := models.User{
+		ID:           generateID("user"),
+		Username:     req.Username,
+		PasswordHash: string(hash),
+		Role:         req.Role,
+		CreatedAt:    now,
+		UpdatedAt:    now,
+	}
+
+	users = append(users, user)
+	if err := a.configManager.SaveUsers(users); err != nil {
+		writeError(w, http.StatusInternalServerError, "ошибка сохранения пользователя")
+		return
+	}
+
+	writeJSON(w, http.StatusCreated, map[string]string{
+		"id":       user.ID,
+		"username": user.Username,
+		"role":     string(user.Role),
+	})
+}
+
+// handleUpdateUser — PUT /api/users/{id} — обновление пользователя.
+func (a *API) handleUpdateUser(w http.ResponseWriter, r *http.Request) {
+	userID := r.PathValue("id")
+	if userID == "" {
+		writeError(w, http.StatusBadRequest, "не указан id пользователя")
+		return
+	}
+
+	var req models.UpdateUserRequest
+	if err := decodeJSON(r, &req); err != nil {
+		writeError(w, http.StatusBadRequest, "некорректный JSON")
+		return
+	}
+
+	users, err := a.configManager.ReadUsers()
+	if err != nil {
+		writeError(w, http.StatusInternalServerError, "ошибка чтения пользователей")
+		return
+	}
+
+	idx := findUserIndex(users, userID)
+	if idx < 0 {
+		writeError(w, http.StatusNotFound, "пользователь не найден")
+		return
+	}
+
+	u := &users[idx]
+	if req.Username != nil {
+		// Проверка уникальности
+		for i, other := range users {
+			if other.Username == *req.Username && i != idx {
+				writeError(w, http.StatusConflict, "пользователь с таким именем уже существует")
+				return
+			}
+		}
+		u.Username = *req.Username
+	}
+	if req.Password != nil {
+		hash, _ := bcrypt.GenerateFromPassword([]byte(*req.Password), bcrypt.DefaultCost)
+		u.PasswordHash = string(hash)
+	}
+	if req.Role != nil {
+		if *req.Role != models.RoleAdmin && *req.Role != models.RoleViewer {
+			writeError(w, http.StatusBadRequest, "роль должна быть admin или viewer")
+			return
+		}
+		// Защита первичного администратора от понижения роли
+		if userID == "user-01" && *req.Role != models.RoleAdmin {
+			writeError(w, http.StatusConflict, "роль первичного администратора нельзя изменить")
+			return
+		}
+		u.Role = *req.Role
+	}
+	u.UpdatedAt = time.Now().UTC()
+
+	if err := a.configManager.SaveUsers(users); err != nil {
+		writeError(w, http.StatusInternalServerError, "ошибка сохранения пользователя")
+		return
+	}
+
+	writeJSON(w, http.StatusOK, map[string]string{
+		"id":       u.ID,
+		"username": u.Username,
+		"role":     string(u.Role),
+	})
+}
+
+// handleDeleteUser — DELETE /api/users/{id} — удаление пользователя.
+func (a *API) handleDeleteUser(w http.ResponseWriter, r *http.Request) {
+	userID := r.PathValue("id")
+	if userID == "" {
+		writeError(w, http.StatusBadRequest, "не указан id пользователя")
+		return
+	}
+
+	users, err := a.configManager.ReadUsers()
+	if err != nil {
+		writeError(w, http.StatusInternalServerError, "ошибка чтения пользователей")
+		return
+	}
+
+	idx := findUserIndex(users, userID)
+	if idx < 0 {
+		writeError(w, http.StatusNotFound, "пользователь не найден")
+		return
+	}
+
+	// Защита первичного администратора от удаления
+	if userID == "user-01" {
+		writeError(w, http.StatusConflict, "первичного администратора нельзя удалить")
+		return
+	}
+
+	// Не даём удалить последнего админа
+	adminCount := 0
+	for _, u := range users {
+		if u.Role == models.RoleAdmin {
+			adminCount++
+		}
+	}
+	if users[idx].Role == models.RoleAdmin && adminCount <= 1 {
+		writeError(w, http.StatusConflict, "нельзя удалить последнего администратора")
+		return
+	}
+
+	users = append(users[:idx], users[idx+1:]...)
+	if err := a.configManager.SaveUsers(users); err != nil {
+		writeError(w, http.StatusInternalServerError, "ошибка сохранения пользователей")
+		return
+	}
+
+	writeJSON(w, http.StatusNoContent, nil)
+}
+
+// findUserIndex находит индекс пользователя по ID.
+func findUserIndex(users []models.User, id string) int {
+	for i := range users {
+		if users[i].ID == id {
+			return i
+		}
+	}
+	return -1
+}
+
+// generateID генерирует ID вида "prefix-XXXXX".
+func generateID(prefix string) string {
+	return fmt.Sprintf("%s-%s", prefix, randomHex(6))
+}
+
+// randomHex генерирует случайную hex-строку заданной длины.
+func randomHex(n int) string {
+	b := make([]byte, n)
+	if _, err := rand.Read(b); err != nil {
+		// fallback на time-based, если crypto/rand недоступен
+		return fmt.Sprintf("%x", time.Now().UnixNano())
+	}
+	return hex.EncodeToString(b)[:n]
+}

internal/api/ws.go

@@ -0,0 +1,161 @@
+package api
+
+import (
+	"fmt"
+	"log"
+	"net/http"
+	"sync"
+
+	"github.com/golang-jwt/jwt/v5"
+	"github.com/gorilla/websocket"
+
+	"github.com/pulse-lets-go/internal/models"
+)
+
+var upgrader = websocket.Upgrader{
+	ReadBufferSize:  1024,
+	WriteBufferSize: 1024,
+	CheckOrigin: func(r *http.Request) bool {
+		return true // Разрешаем все origins для dev
+	},
+}
+
+// wsClient — соединение WebSocket одного клиента.
+type wsClient struct {
+	conn *websocket.Conn
+	mu   sync.Mutex
+}
+
+// wsHub управляет подключёнными WebSocket-клиентами и рассылает метрики.
+type wsHub struct {
+	mu      sync.RWMutex
+	clients map[*wsClient]bool
+}
+
+// newWSHub создаёт хаб WebSocket.
+func newWSHub() *wsHub {
+	return &wsHub{
+		clients: make(map[*wsClient]bool),
+	}
+}
+
+// add добавляет клиента в хаб.
+func (h *wsHub) add(c *wsClient) {
+	h.mu.Lock()
+	h.clients[c] = true
+	h.mu.Unlock()
+}
+
+// remove удаляет клиента из хаба.
+func (h *wsHub) remove(c *wsClient) {
+	h.mu.Lock()
+	if h.clients[c] {
+		c.conn.Close()
+		delete(h.clients, c)
+	}
+	h.mu.Unlock()
+}
+
+// broadcast рассылает метрики всем подключённым клиентам.
+func (h *wsHub) broadcast(msg *models.WsMetricsMessage) {
+	h.mu.RLock()
+	defer h.mu.RUnlock()
+
+	for client := range h.clients {
+		client.mu.Lock()
+		err := client.conn.WriteJSON(msg)
+		client.mu.Unlock()
+		if err != nil {
+			log.Printf("[ws] ошибка отправки: %v", err)
+			go h.remove(client)
+		}
+	}
+}
+
+// handleWS — WebSocket /ws/metrics.
+func (a *API) handleWS(w http.ResponseWriter, r *http.Request) {
+	token := r.URL.Query().Get("token")
+	if token == "" {
+		// пробуем заголовок
+		token = extractBearerToken(r)
+	}
+	if token == "" {
+		writeError(w, http.StatusUnauthorized, "требуется токен")
+		return
+	}
+
+	// Валидация JWT
+	userInfo, err := a.validateToken(token)
+	if err != nil {
+		writeError(w, http.StatusUnauthorized, "недействительный токен")
+		return
+	}
+
+	conn, err := upgrader.Upgrade(w, r, nil)
+	if err != nil {
+		log.Printf("[ws] ошибка upgrade: %v", err)
+		return
+	}
+
+	client := &wsClient{conn: conn}
+	a.wsHub.add(client)
+
+	log.Printf("[ws] клиент подключён: %s (%s)", userInfo.Username, r.RemoteAddr)
+
+	// Отправляем текущее состояние при подключении
+	go func() {
+		nodes := a.engine.GetAllNodes()
+		msg := &models.WsMetricsMessage{
+			Type:    "nodes_update",
+			Payload: nodes,
+		}
+		a.wsHub.broadcast(msg)
+	}()
+
+	// Читаем из вебсокета (ping/pong + закрытие)
+	go func() {
+		defer a.wsHub.remove(client)
+		for {
+			_, _, err := conn.ReadMessage()
+			if err != nil {
+				log.Printf("[ws] клиент отключён: %s", r.RemoteAddr)
+				return
+			}
+		}
+	}()
+}
+
+// BroadcastMetrics рассылает метрики всем WS-клиентам (вызывается engine при обновлении).
+func (a *API) BroadcastMetrics() {
+	nodes := a.engine.GetAllNodes()
+	msg := &models.WsMetricsMessage{
+		Type:    "nodes_update",
+		Payload: nodes,
+	}
+	a.wsHub.broadcast(msg)
+}
+
+// validateToken проверяет JWT и возвращает UserInfo.
+func (a *API) validateToken(tokenStr string) (*UserInfo, error) {
+	token, err := parseJWT(tokenStr, a.jwtSecret)
+	if err != nil {
+		return nil, err
+	}
+	return token, nil
+}
+
+// parseJWT парсит JWT токен.
+func parseJWT(tokenStr string, secret string) (*UserInfo, error) {
+	c := &claims{}
+	token, err := jwt.ParseWithClaims(tokenStr, c, func(token *jwt.Token) (interface{}, error) {
+		return []byte(secret), nil
+	})
+	if err != nil || !token.Valid {
+		return nil, fmt.Errorf("недействительный токен: %w", err)
+	}
+	return &UserInfo{
+		UserID:   c.UserID,
+		Username: c.Username,
+		Role:     c.Role,
+	}, nil
+}

internal/config/manager.go

@@ -0,0 +1,420 @@
+// Package config управляет JSON-конфигами приложения: config.json, trunks.json, users.json.
+// Обеспечивает атомарную запись (tmp → rename) и thread-safe доступ через sync.RWMutex.
+package config
+
+import (
+	"crypto/rand"
+	"encoding/hex"
+	"encoding/json"
+	"fmt"
+	"math"
+	"os"
+	"path/filepath"
+	"strings"
+	"sync"
+	"time"
+
+	"github.com/pulse-lets-go/internal/models"
+)
+
+// ScoringWeights — веса компонентов скора.
+type ScoringWeights struct {
+	CallScore float64 `json:"call_score"`
+	LoadScore float64 `json:"load_score"`
+	IdleScore float64 `json:"idle_score"`
+	FailScore float64 `json:"fail_score"`
+}
+
+// ScoringConfig — пороги и веса для scoring engine.
+type ScoringConfig struct {
+	IdleCPUMin           float64        `json:"idle_cpu_min"`
+	CallFailureRateLethal float64       `json:"call_failure_rate_lethal"`
+	Weights              ScoringWeights `json:"weights"`
+}
+
+// TLSConfig — настройки HTTPS.
+type TLSConfig struct {
+	Enabled  bool   `json:"enabled"`
+	CertFile string `json:"cert_file"`
+	KeyFile  string `json:"key_file"`
+}
+
+// RateLimitConfig — ограничения частоты запросов.
+type RateLimitConfig struct {
+	Enabled     bool `json:"enabled"`
+	RoutePerSec int  `json:"route_per_sec"`
+	APIPerSec   int  `json:"api_per_sec"`
+}
+
+// LogConfig — настройки логирования.
+type LogConfig struct {
+	Level  string `json:"level"`  // debug, info, warn, error
+	Format string `json:"format"` // text, json
+}
+
+// ESLConfig — настройки подключения к FreeSWITCH ESL.
+type ESLConfig struct {
+	Host          string `json:"host"`          // если пустой — ESL не запускается
+	Port          int    `json:"port"`          // порт ESL (по умолчанию 8021)
+	Password      string `json:"password"`
+	PasswordEnv   string `json:"password_env"`  // имя переменной окружения с паролем
+	SofiaProfile  string `json:"sofia_profile"` // профиль Sofia (external/internal)
+	GatewayPrefix string `json:"gateway_prefix"` // префикс gateway (pulse)
+}
+
+// GetPassword возвращает ESL-пароль: из переменной окружения, если задан password_env, иначе из поля password.
+func (e *ESLConfig) GetPassword() string {
+	if e.PasswordEnv != "" {
+		if val := os.Getenv(e.PasswordEnv); val != "" {
+			return val
+		}
+	}
+	return e.Password
+}
+
+// Config — корневая конфигурация приложения (config.json).
+type Config struct {
+	NatsURL           string           `json:"nats_url"`
+	NatsUser          string           `json:"nats_user"`
+	NatsPassword      string           `json:"nats_password"`
+	ListenAddr        string           `json:"listen_addr"`
+	JWTSecret         string           `json:"jwt_secret"`
+	MonitoringAPIKey  string           `json:"monitoring_api_key"`
+	StaleThresholdSec int              `json:"stale_threshold_sec"`
+	Scoring           ScoringConfig    `json:"scoring"`
+	TLS               TLSConfig        `json:"tls"`
+	RateLimit         RateLimitConfig  `json:"rate_limit"`
+	Log               LogConfig        `json:"log"`
+	ESL               ESLConfig        `json:"esl"`
+}
+
+// Validate проверяет корректность всех полей конфига.
+// Возвращает читаемое описание всех найденных ошибок.
+func (c *Config) Validate() error {
+	var errs []string
+
+	if c.NatsURL == "" {
+		errs = append(errs, "nats_url обязателен")
+	}
+	if c.ListenAddr == "" {
+		errs = append(errs, "listen_addr обязателен")
+	}
+	if c.StaleThresholdSec <= 0 {
+		errs = append(errs, "stale_threshold_sec должен быть > 0")
+	}
+	if c.JWTSecret == "" {
+		errs = append(errs, "jwt_secret обязателен")
+	}
+	if c.MonitoringAPIKey == "" {
+		errs = append(errs, "monitoring_api_key обязателен")
+	}
+	if c.Scoring.IdleCPUMin < 0 {
+		errs = append(errs, "scoring.idle_cpu_min должен быть >= 0")
+	}
+	if c.Scoring.CallFailureRateLethal < 0 || c.Scoring.CallFailureRateLethal > 100 {
+		errs = append(errs, "scoring.call_failure_rate_lethal должен быть 0..100")
+	}
+
+	w := &c.Scoring.Weights
+	sum := w.CallScore + w.LoadScore + w.IdleScore + w.FailScore
+	if math.Abs(sum-1.0) > 0.01 {
+		errs = append(errs, fmt.Sprintf("scoring.weights сумма должна быть ≈1.0 (сейчас %.2f)", sum))
+	}
+
+	if c.TLS.Enabled {
+		if c.TLS.CertFile == "" || c.TLS.KeyFile == "" {
+			errs = append(errs, "tls.cert_file и tls.key_file обязательны при tls.enabled=true")
+		}
+	}
+
+	if c.RateLimit.Enabled {
+		if c.RateLimit.RoutePerSec <= 0 {
+			errs = append(errs, "rate_limit.route_per_sec должен быть > 0")
+		}
+		if c.RateLimit.APIPerSec <= 0 {
+			errs = append(errs, "rate_limit.api_per_sec должен быть > 0")
+		}
+	}
+
+	switch c.Log.Level {
+	case "debug", "info", "warn", "error", "":
+	default:
+		errs = append(errs, "log.level должен быть debug/info/warn/error")
+	}
+	switch c.Log.Format {
+	case "text", "json", "":
+	default:
+		errs = append(errs, "log.format должен быть text/json")
+	}
+
+	// ESL validation
+	if c.ESL.Host != "" {
+		if c.ESL.Port <= 0 || c.ESL.Port > 65535 {
+			errs = append(errs, "esl.port должен быть 1-65535")
+		}
+		if c.ESL.SofiaProfile == "" {
+			errs = append(errs, "esl.sofia_profile обязателен при esl.host")
+		}
+		if c.ESL.Password == "" && c.ESL.PasswordEnv == "" {
+			errs = append(errs, "esl.password или esl.password_env обязателен при esl.host")
+		}
+	}
+
+	if len(errs) > 0 {
+		return fmt.Errorf("ошибки конфигурации:\n  - %s", strings.Join(errs, "\n  - "))
+	}
+	return nil
+}
+
+// Manager управляет чтением и атомарной записью JSON-конфигов.
+type Manager struct {
+	mu   sync.RWMutex
+	dir  string // путь к data/
+}
+
+// NewManager создаёт новый менеджер конфигов из директории dataDir.
+// Если файлы отсутствуют — создаёт их с дефолтными значениями.
+func NewManager(dataDir string) (*Manager, error) {
+	// Убеждаемся, что директория существует
+	if err := os.MkdirAll(dataDir, 0750); err != nil {
+		return nil, fmt.Errorf("создание data/: %w", err)
+	}
+
+	m := &Manager{dir: dataDir}
+
+	// Инициализируем конфиги при первом запуске
+	if _, err := os.Stat(m.configPath()); os.IsNotExist(err) {
+		if err := m.createDefaultConfig(); err != nil {
+			return nil, fmt.Errorf("создание config.json: %w", err)
+		}
+	}
+	if _, err := os.Stat(m.trunksPath()); os.IsNotExist(err) {
+		if err := m.saveFile(m.trunksPath(), []models.Trunk{}); err != nil {
+			return nil, fmt.Errorf("создание trunks.json: %w", err)
+		}
+	}
+	if _, err := os.Stat(m.usersPath()); os.IsNotExist(err) {
+		if err := m.createDefaultUsers(); err != nil {
+			return nil, fmt.Errorf("создание users.json: %w", err)
+		}
+	}
+
+	return m, nil
+}
+
+// ReadConfig читает config.json. Потокобезопасно.
+func (m *Manager) ReadConfig() (*Config, error) {
+	m.mu.RLock()
+	defer m.mu.RUnlock()
+
+	data, err := os.ReadFile(m.configPath())
+	if err != nil {
+		return nil, fmt.Errorf("чтение config.json: %w", err)
+	}
+
+	var cfg Config
+	if err := json.Unmarshal(data, &cfg); err != nil {
+		return nil, fmt.Errorf("парсинг config.json: %w", err)
+	}
+	return &cfg, nil
+}
+
+// SaveConfig атомарно сохраняет config.json.
+func (m *Manager) SaveConfig(cfg *Config) error {
+	m.mu.Lock()
+	defer m.mu.Unlock()
+
+	data, err := json.MarshalIndent(cfg, "", "  ")
+	if err != nil {
+		return fmt.Errorf("сериализация config.json: %w", err)
+	}
+	return m.saveFile(m.configPath(), data)
+}
+
+// ReadTrunks читает trunks.json. Потокобезопасно.
+func (m *Manager) ReadTrunks() ([]models.Trunk, error) {
+	m.mu.RLock()
+	defer m.mu.RUnlock()
+	return m.readTrunksLocked()
+}
+
+// readTrunksLocked — внутреннее чтение без блокировки (вызывающий держит lock).
+func (m *Manager) readTrunksLocked() ([]models.Trunk, error) {
+	data, err := os.ReadFile(m.trunksPath())
+	if err != nil {
+		return nil, fmt.Errorf("чтение trunks.json: %w", err)
+	}
+	var trunks []models.Trunk
+	if err := json.Unmarshal(data, &trunks); err != nil {
+		return nil, fmt.Errorf("парсинг trunks.json: %w", err)
+	}
+	return trunks, nil
+}
+
+// SaveTrunks атомарно сохраняет trunks.json.
+func (m *Manager) SaveTrunks(trunks []models.Trunk) error {
+	m.mu.Lock()
+	defer m.mu.Unlock()
+	return m.saveTrunksLocked(trunks)
+}
+
+func (m *Manager) saveTrunksLocked(trunks []models.Trunk) error {
+	data, err := json.MarshalIndent(trunks, "", "  ")
+	if err != nil {
+		return fmt.Errorf("сериализация trunks.json: %w", err)
+	}
+	return m.saveFile(m.trunksPath(), data)
+}
+
+// ReadUsers читает users.json. Потокобезопасно.
+func (m *Manager) ReadUsers() ([]models.User, error) {
+	m.mu.RLock()
+	defer m.mu.RUnlock()
+	return m.readUsersLocked()
+}
+
+func (m *Manager) readUsersLocked() ([]models.User, error) {
+	data, err := os.ReadFile(m.usersPath())
+	if err != nil {
+		return nil, fmt.Errorf("чтение users.json: %w", err)
+	}
+	var users []models.User
+	if err := json.Unmarshal(data, &users); err != nil {
+		return nil, fmt.Errorf("парсинг users.json: %w", err)
+	}
+	return users, nil
+}
+
+// SaveUsers атомарно сохраняет users.json.
+func (m *Manager) SaveUsers(users []models.User) error {
+	m.mu.Lock()
+	defer m.mu.Unlock()
+	return m.saveUsersLocked(users)
+}
+
+func (m *Manager) saveUsersLocked(users []models.User) error {
+	data, err := json.MarshalIndent(users, "", "  ")
+	if err != nil {
+		return fmt.Errorf("сериализация users.json: %w", err)
+	}
+	return m.saveFile(m.usersPath(), data)
+}
+
+// --- Приватные методы ---
+
+func (m *Manager) configPath() string  { return filepath.Join(m.dir, "config.json") }
+func (m *Manager) trunksPath() string  { return filepath.Join(m.dir, "trunks.json") }
+func (m *Manager) usersPath() string   { return filepath.Join(m.dir, "users.json") }
+
+// saveFile атомарно сохраняет данные в файл: tmp → rename.
+// Вызывающий держит write lock.
+func (m *Manager) saveFile(path string, data interface{}) error {
+	var raw []byte
+	var err error
+
+	switch v := data.(type) {
+	case []byte:
+		raw = v
+	default:
+		raw, err = json.MarshalIndent(data, "", "  ")
+		if err != nil {
+			return fmt.Errorf("сериализация: %w", err)
+		}
+	}
+
+	tmpPath := path + ".tmp"
+	if err := os.WriteFile(tmpPath, raw, 0640); err != nil {
+		return fmt.Errorf("запись временного файла: %w", err)
+	}
+
+	if err := os.Rename(tmpPath, path); err != nil {
+		os.Remove(tmpPath) // clean up
+		return fmt.Errorf("атомарный rename: %w", err)
+	}
+
+	return nil
+}
+
+// createDefaultConfig генерирует config.json со значениями по умолчанию.
+func (m *Manager) createDefaultConfig() error {
+	jwtSecret, err := generateRandomHex(32)
+	if err != nil {
+		return err
+	}
+	apiKey, err := generateRandomHex(32)
+	if err != nil {
+		return err
+	}
+
+	cfg := Config{
+		NatsURL:           "nats://localhost:4222",
+		NatsUser:          "",
+		NatsPassword:      "",
+		ListenAddr:        ":8080",
+		JWTSecret:         jwtSecret,
+		MonitoringAPIKey:  apiKey,
+		StaleThresholdSec: 20,
+		Scoring: ScoringConfig{
+			IdleCPUMin:           5.0,
+			CallFailureRateLethal: 15.0,
+			Weights: ScoringWeights{
+				CallScore: 0.40,
+				LoadScore: 0.30,
+				IdleScore: 0.20,
+				FailScore: 0.10,
+			},
+		},
+		TLS: TLSConfig{
+			Enabled:  false,
+			CertFile: "",
+			KeyFile:  "",
+		},
+		RateLimit: RateLimitConfig{
+			Enabled:     true,
+			RoutePerSec: 5000,
+			APIPerSec:   100,
+		},
+		Log: LogConfig{
+			Level:  "info",
+			Format: "text",
+		},
+		ESL: ESLConfig{
+			Host:          "",
+			Port:          8021,
+			Password:      "",
+			PasswordEnv:   "",
+			SofiaProfile:  "external",
+			GatewayPrefix: "pulse",
+		},
+	}
+
+	return m.SaveConfig(&cfg)
+}
+
+// createDefaultUsers создаёт users.json с дефолтным админом (admin/admin).
+// Пароль хранится в bcrypt. На первом запуске запрашивается смена.
+func (m *Manager) createDefaultUsers() error {
+	// Используем плейсхолдер-хэш "admin" — при первом логине админ обязан сменить пароль.
+	// Хэш будет заменён на bcrypt при создании/обновлении через API.
+	defaultTime := time.Now().UTC()
+	users := []models.User{
+		{
+			ID:        "user-01",
+			Username:  "admin",
+			Role:      models.RoleAdmin,
+			CreatedAt: defaultTime,
+			UpdatedAt: defaultTime,
+			// PasswordHash будет установлен при первом логине через API
+		},
+	}
+	return m.saveUsersLocked(users)
+}
+
+// generateRandomHex генерирует случайную hex-строку заданной длины в байтах.
+func generateRandomHex(bytes int) (string, error) {
+	buf := make([]byte, bytes)
+	if _, err := rand.Read(buf); err != nil {
+		return "", fmt.Errorf("генерация случайных байт: %w", err)
+	}
+	return hex.EncodeToString(buf), nil
+}

internal/engine/engine.go

@@ -0,0 +1,331 @@
+// Package engine содержит scoring engine и router выбора лучшей ноды.
+// Потокобезопасен: RWMutex разделяет чтение (роутинг) и запись (обновление метрик).
+package engine
+
+import (
+	"fmt"
+	"sync"
+	"sync/atomic"
+	"time"
+
+	"github.com/pulse-lets-go/internal/config"
+	"github.com/pulse-lets-go/internal/models"
+)
+
+const defaultRingCapacity = 360 // 30 минут истории при метриках каждые 5 сек
+
+// Engine управляет состоянием нод и вычислением скора.
+type Engine struct {
+	mu    sync.RWMutex
+	nodes map[string]*models.NodeState
+	rings map[string]*MetricsRingBuffer // история метрик на каждую ноду
+	cfg   *config.Config
+
+	// Кэш для O(1) доступа из /api/route
+	bestNodeID     string
+	bestScore      float64
+	fallbackActive bool // true, если все ноды имеют score < 0
+
+	// Статистика для health endpoint
+	startTime      time.Time
+	routeRequests  atomic.Int64
+	lastMetricTime atomic.Int64 // unix ts последней полученной метрики
+}
+
+// NewEngine создаёт новый engine с заданной конфигурацией.
+func NewEngine(cfg *config.Config) *Engine {
+	return &Engine{
+		nodes:     make(map[string]*models.NodeState),
+		rings:     make(map[string]*MetricsRingBuffer),
+		cfg:       cfg,
+		bestScore: -1,
+		startTime: time.Now(),
+	}
+}
+
+// UpdateConfig обновляет конфигурацию скоринга (при изменении через API).
+func (e *Engine) UpdateConfig(cfg *config.Config) {
+	e.mu.Lock()
+	defer e.mu.Unlock()
+	e.cfg = cfg
+	e.recalculateAll()
+}
+
+// UpdateMetric принимает метрику из NATS, обновляет состояние ноды и пересчитывает score.
+// disabled-флаг НЕ трогается — он управляется только через ToggleNode.
+func (e *Engine) UpdateMetric(m *models.NodeMetric) *models.NodeState {
+	e.mu.Lock()
+	defer e.mu.Unlock()
+
+	ns, exists := e.nodes[m.NodeID]
+	if !exists {
+		ns = &models.NodeState{NodeMetric: *m}
+		e.nodes[m.NodeID] = ns
+	} else {
+		// Сохраняем admin-флаги
+		disabled := ns.Disabled
+		disabledReason := ns.DisabledReason
+		ns.NodeMetric = *m
+		ns.Disabled = disabled
+		ns.DisabledReason = disabledReason
+	}
+
+	e.scoreNodeLocked(ns)
+	e.recalcBestLocked()
+
+	// Обновляем время последней метрики
+	e.lastMetricTime.Store(m.TS)
+
+	// Добавляем снапшот в кольцевой буфер истории
+	ring, ok := e.rings[m.NodeID]
+	if !ok {
+		ring = newMetricsRingBuffer(defaultRingCapacity)
+		e.rings[m.NodeID] = ring
+	}
+	ring.push(NodeSnapshot{
+		ActiveCalls:     ns.ActiveCalls,
+		MaxCalls:        ns.MaxCalls,
+		IdleCPU:         ns.IdleCPU,
+		LoadAvg:         ns.LoadAvg,
+		CallFailureRate: ns.CallFailureRate,
+		Score:           ns.Score,
+		TS:              ns.TS,
+	})
+
+	return ns
+}
+
+// GetBestNode возвращает ID лучшей ноды и fallback-статус.
+// O(1) — читает кэш, не сканирует все ноды.
+func (e *Engine) GetBestNode() (nodeID string, score float64, fallback bool) {
+	e.mu.RLock()
+	defer e.mu.RUnlock()
+
+	if len(e.nodes) == 0 {
+		return "", 0, true
+	}
+	return e.bestNodeID, e.bestScore, e.fallbackActive
+}
+
+// GetNodeInfo возвращает информацию о конкретной ноде.
+func (e *Engine) GetNodeInfo(nodeID string) (*models.NodeInfo, bool) {
+	e.mu.RLock()
+	defer e.mu.RUnlock()
+
+	ns, exists := e.nodes[nodeID]
+	if !exists {
+		return nil, false
+	}
+	return stateToNodeInfo(ns, e.cfg.StaleThresholdSec, time.Now()), true
+}
+
+// GetAllNodes возвращает массив NodeInfo для всех нод.
+func (e *Engine) GetAllNodes() []*models.NodeInfo {
+	e.mu.RLock()
+	defer e.mu.RUnlock()
+
+	now := time.Now()
+	result := make([]*models.NodeInfo, 0, len(e.nodes))
+	for _, ns := range e.nodes {
+		result = append(result, stateToNodeInfo(ns, e.cfg.StaleThresholdSec, now))
+	}
+	return result
+}
+
+// GetNodeHistory возвращает историю метрик ноды из ring buffer.
+func (e *Engine) GetNodeHistory(nodeID string) []NodeSnapshot {
+	e.mu.RLock()
+	defer e.mu.RUnlock()
+
+	ring, ok := e.rings[nodeID]
+	if !ok {
+		return nil
+	}
+	return ring.snapshot()
+}
+
+// ToggleNode включает/выключает ноду из распределения.
+func (e *Engine) ToggleNode(nodeID string, disabled bool, reason string) error {
+	e.mu.Lock()
+	defer e.mu.Unlock()
+
+	ns, exists := e.nodes[nodeID]
+	if !exists {
+		return fmt.Errorf("нода %s не найдена", nodeID)
+	}
+
+	ns.Disabled = disabled
+	if disabled {
+		ns.DisabledReason = reason
+	} else {
+		ns.DisabledReason = ""
+	}
+
+	e.scoreNodeLocked(ns)
+	e.recalcBestLocked()
+	return nil
+}
+
+// HasRecentMetrics возвращает true, если была получена хотя бы одна метрика за последние N секунд.
+func (e *Engine) HasRecentMetrics(seconds int64) bool {
+	lastTS := e.lastMetricTime.Load()
+	if lastTS == 0 {
+		return false
+	}
+	return time.Now().Unix()-lastTS <= seconds
+}
+
+// IncrementRouteRequests увеличивает счётчик запросов /api/route.
+func (e *Engine) IncrementRouteRequests() {
+	e.routeRequests.Add(1)
+}
+
+// HealthStats возвращает статистику для health endpoint.
+type HealthStats struct {
+	TotalNodes     int `json:"total_nodes"`
+	HealthyNodes   int `json:"healthy_nodes"`
+	RouteRequests  int64 `json:"route_requests_total"`
+	UptimeSeconds  int64 `json:"uptime_seconds"`
+	LastMetricTS   int64 `json:"last_metric_ts"`
+}
+
+// GetHealthStats возвращает текущую HealthStats (потокобезопасно).
+func (e *Engine) GetHealthStats() HealthStats {
+	e.mu.RLock()
+	defer e.mu.RUnlock()
+
+	healthy := 0
+	for _, ns := range e.nodes {
+		if ns.Score >= 0 && !ns.Disabled {
+			healthy++
+		}
+	}
+	return HealthStats{
+		TotalNodes:     len(e.nodes),
+		HealthyNodes:   healthy,
+		RouteRequests:  e.routeRequests.Load(),
+		UptimeSeconds:  int64(time.Since(e.startTime).Seconds()),
+		LastMetricTS:   e.lastMetricTime.Load(),
+	}
+}
+
+// --- Приватные методы ---
+
+// scoreNodeLocked вычисляет score для одной ноды.
+// Вызывающий держит write lock.
+func (e *Engine) scoreNodeLocked(ns *models.NodeState) {
+	sc := &e.cfg.Scoring
+
+	// 1. Проверка lethal-условий
+	if ns.Disabled {
+		ns.Score = -100
+		ns.LethalReason = fmt.Sprintf("disabled: %s", ns.DisabledReason)
+		return
+	}
+	if ns.Status != "ok" {
+		ns.Score = -100
+		ns.LethalReason = fmt.Sprintf("status: %s", ns.Status)
+		return
+	}
+
+	now := time.Now().Unix()
+	staleSec := int(now - ns.TS)
+	if staleSec > e.cfg.StaleThresholdSec {
+		ns.Score = -100
+		ns.LethalReason = fmt.Sprintf("stale: %d сек без метрик", staleSec)
+		return
+	}
+
+	if ns.ActiveCalls >= ns.MaxCalls && ns.MaxCalls > 0 {
+		ns.Score = -100
+		ns.LethalReason = "active_calls >= max_calls"
+		return
+	}
+
+	if ns.IdleCPU < sc.IdleCPUMin {
+		ns.Score = -100
+		ns.LethalReason = fmt.Sprintf("idle_cpu %.1f < %.0f", ns.IdleCPU, sc.IdleCPUMin)
+		return
+	}
+
+	if ns.CallFailureRate > sc.CallFailureRateLethal {
+		ns.Score = -100
+		ns.LethalReason = fmt.Sprintf("call_failure_rate %.1f > %.0f", ns.CallFailureRate, sc.CallFailureRateLethal)
+		return
+	}
+
+	// 2. Weighted score
+	ns.LethalReason = ""
+
+	callScore := clamp(100.0-(float64(ns.ActiveCalls)/float64(ns.MaxCalls)*100.0), 0, 100)
+	loadScore := clamp(100.0-(ns.LoadAvg*50.0), 0, 100)
+	idleScore := clamp(ns.IdleCPU, 0, 100)
+	failScore := clamp(100.0-ns.CallFailureRate, 0, 100)
+
+	w := &sc.Weights
+	ns.Score = callScore*w.CallScore + loadScore*w.LoadScore + idleScore*w.IdleScore + failScore*w.FailScore
+}
+
+// recalcBestLocked пересчитывает кэш лучшей ноды.
+// Вызывающий держит write lock.
+func (e *Engine) recalcBestLocked() {
+	bestID := ""
+	bestScore := -999.0
+	anyHealthy := false
+
+	for id, ns := range e.nodes {
+		if ns.Score >= 0 {
+			anyHealthy = true
+		}
+		if ns.Score > bestScore {
+			bestScore = ns.Score
+			bestID = id
+		}
+	}
+
+	e.bestNodeID = bestID
+	e.bestScore = bestScore
+	e.fallbackActive = !anyHealthy
+}
+
+// recalculateAll пересчитывает score всех нод и обновляет кэш.
+func (e *Engine) recalculateAll() {
+	for _, ns := range e.nodes {
+		e.scoreNodeLocked(ns)
+	}
+	e.recalcBestLocked()
+}
+
+// stateToNodeInfo конвертирует NodeState в NodeInfo для API.
+func stateToNodeInfo(ns *models.NodeState, staleThresholdSec int, now time.Time) *models.NodeInfo {
+	secondsAgo := now.Sub(time.Unix(ns.TS, 0)).Seconds()
+	isStale := int(secondsAgo) > staleThresholdSec
+
+	return &models.NodeInfo{
+		NodeID:          ns.NodeID,
+		TS:              ns.TS,
+		Status:          ns.Status,
+		ActiveCalls:     ns.ActiveCalls,
+		MaxCalls:        ns.MaxCalls,
+		IdleCPU:         ns.IdleCPU,
+		LoadAvg:         ns.LoadAvg,
+		CallFailureRate: ns.CallFailureRate,
+		Disabled:        ns.Disabled,
+		DisabledReason:  ns.DisabledReason,
+		Score:           ns.Score,
+		LethalReason:    ns.LethalReason,
+		IsStale:         isStale,
+		SecondsAgo:      secondsAgo,
+	}
+}
+
+// clamp ограничивает значение диапазоном [minVal, maxVal].
+func clamp(v, minVal, maxVal float64) float64 {
+	if v < minVal {
+		return minVal
+	}
+	if v > maxVal {
+		return maxVal
+	}
+	return v
+}

internal/engine/engine_test.go

@@ -0,0 +1,340 @@
+package engine
+
+import (
+	"testing"
+	"time"
+
+	"github.com/pulse-lets-go/internal/config"
+	"github.com/pulse-lets-go/internal/models"
+)
+
+func defaultCfg() *config.Config {
+	return &config.Config{
+		StaleThresholdSec: 20,
+		Scoring: config.ScoringConfig{
+			IdleCPUMin:           5.0,
+			CallFailureRateLethal: 15.0,
+			Weights: config.ScoringWeights{
+				CallScore: 0.40,
+				LoadScore: 0.30,
+				IdleScore: 0.20,
+				FailScore: 0.10,
+			},
+		},
+	}
+}
+
+func freshMetric(nodeID string) *models.NodeMetric {
+	return &models.NodeMetric{
+		NodeID:          nodeID,
+		TS:              time.Now().Unix(),
+		Status:          "ok",
+		ActiveCalls:     42,
+		MaxCalls:        250,
+		IdleCPU:         35,
+		LoadAvg:         0.85,
+		CallFailureRate: 0.5,
+	}
+}
+
+func TestNewEngine(t *testing.T) {
+	eng := NewEngine(defaultCfg())
+	if eng == nil {
+		t.Fatal("ожидался engine, получен nil")
+	}
+}
+
+func TestUpdateMetric_CreatesNode(t *testing.T) {
+	eng := NewEngine(defaultCfg())
+	m := freshMetric("pbx-01")
+	ns := eng.UpdateMetric(m)
+
+	if ns.NodeID != "pbx-01" {
+		t.Errorf("ожидался node_id=pbx-01, получен %s", ns.NodeID)
+	}
+	if len(eng.nodes) != 1 {
+		t.Errorf("ожидалась 1 нода, получено %d", len(eng.nodes))
+	}
+}
+
+func TestUpdateMetric_PreservesDisabled(t *testing.T) {
+	eng := NewEngine(defaultCfg())
+	m := freshMetric("pbx-01")
+	eng.UpdateMetric(m)
+
+	// Отключаем ноду вручную
+	eng.ToggleNode("pbx-01", true, "test")
+	eng.UpdateMetric(m)
+
+	ns, _ := eng.GetNodeInfo("pbx-01")
+	if !ns.Disabled {
+		t.Error("ожидалось disabled=true")
+	}
+	if ns.DisabledReason != "test" {
+		t.Errorf("ожидалась причина 'test', получена '%s'", ns.DisabledReason)
+	}
+
+	// Включаем обратно
+	eng.ToggleNode("pbx-01", false, "")
+	eng.UpdateMetric(m)
+
+	ns, _ = eng.GetNodeInfo("pbx-01")
+	if ns.Disabled {
+		t.Error("ожидалось disabled=false")
+	}
+}
+
+func TestScore_LethalDisabled(t *testing.T) {
+	eng := NewEngine(defaultCfg())
+	m := freshMetric("pbx-01")
+	eng.UpdateMetric(m)
+	eng.ToggleNode("pbx-01", true, "maintenance")
+
+	ns, _ := eng.GetNodeInfo("pbx-01")
+	if ns.Score != -100 {
+		t.Errorf("disabled нода должна иметь score=-100, получен %.0f", ns.Score)
+	}
+}
+
+func TestScore_LethalStatusNotOk(t *testing.T) {
+	eng := NewEngine(defaultCfg())
+	m := freshMetric("pbx-01")
+	m.Status = "down"
+	eng.UpdateMetric(m)
+
+	ns, _ := eng.GetNodeInfo("pbx-01")
+	if ns.Score != -100 {
+		t.Errorf("status==down нода должна иметь score=-100, получен %.0f", ns.Score)
+	}
+}
+
+func TestScore_LethalStale(t *testing.T) {
+	eng := NewEngine(defaultCfg())
+	m := freshMetric("pbx-01")
+	// Устанавливаем ts на 30 секунд назад (stale_threshold=20)
+	m.TS = time.Now().Unix() - 30
+	eng.UpdateMetric(m)
+
+	ns, _ := eng.GetNodeInfo("pbx-01")
+	if ns.Score != -100 {
+		t.Errorf("stale нода должна иметь score=-100, получен %.0f", ns.Score)
+	}
+}
+
+func TestScore_LethalMaxCalls(t *testing.T) {
+	eng := NewEngine(defaultCfg())
+	m := freshMetric("pbx-01")
+	m.ActiveCalls = 250
+	m.MaxCalls = 250
+	eng.UpdateMetric(m)
+
+	ns, _ := eng.GetNodeInfo("pbx-01")
+	if ns.Score != -100 {
+		t.Errorf("нода с исчерпанной ёмкостью должна иметь score=-100, получен %.0f", ns.Score)
+	}
+}
+
+func TestScore_LethalIdleCPU(t *testing.T) {
+	eng := NewEngine(defaultCfg())
+	m := freshMetric("pbx-01")
+	m.IdleCPU = 2.0
+	eng.UpdateMetric(m)
+
+	ns, _ := eng.GetNodeInfo("pbx-01")
+	if ns.Score != -100 {
+		t.Errorf("нода с idle_cpu < 5 должна иметь score=-100, получен %.0f", ns.Score)
+	}
+}
+
+func TestScore_LethalFailureRate(t *testing.T) {
+	eng := NewEngine(defaultCfg())
+	m := freshMetric("pbx-01")
+	m.CallFailureRate = 20.0
+	eng.UpdateMetric(m)
+
+	ns, _ := eng.GetNodeInfo("pbx-01")
+	if ns.Score != -100 {
+		t.Errorf("нода с call_failure_rate > 15 должна иметь score=-100, получен %.0f", ns.Score)
+	}
+}
+
+func TestScore_Healthy(t *testing.T) {
+	eng := NewEngine(defaultCfg())
+	m := freshMetric("pbx-01")
+	ns := eng.UpdateMetric(m)
+
+	if ns.Score <= 0 {
+		t.Errorf("здоровая нода должна иметь положительный score, получен %.0f", ns.Score)
+	}
+}
+
+func TestScore_HealthyFormula(t *testing.T) {
+	eng := NewEngine(defaultCfg())
+	m := freshMetric("pbx-01")
+	m.ActiveCalls = 0
+	m.MaxCalls = 100
+	m.IdleCPU = 100
+	m.LoadAvg = 0
+	m.CallFailureRate = 0
+
+	ns := eng.UpdateMetric(m)
+
+	// Все компоненты = 100
+	// score = 100*0.4 + 100*0.3 + 100*0.2 + 100*0.1 = 100
+	if ns.Score != 100.0 {
+		t.Errorf("идеальная нода должна иметь score=100, получен %.1f", ns.Score)
+	}
+}
+
+func TestScore_WeightedFormula(t *testing.T) {
+	eng := NewEngine(defaultCfg())
+	m := freshMetric("pbx-01")
+	m.ActiveCalls = 50
+	m.MaxCalls = 100
+	m.IdleCPU = 50
+	m.LoadAvg = 1.0
+	m.CallFailureRate = 5.0
+
+	ns := eng.UpdateMetric(m)
+
+	// call_score  = 100 - (50/100 * 100) = 50
+	// load_score  = 100 - (1.0 * 50) = 50
+	// idle_score  = 50
+	// fail_score  = 100 - 5 = 95
+	// score = 50*0.4 + 50*0.3 + 50*0.2 + 95*0.1 = 20+15+10+9.5 = 54.5
+	expected := 54.5
+
+	if ns.Score < expected-0.1 || ns.Score > expected+0.1 {
+		t.Errorf("ожидался score=%.1f, получен %.1f", expected, ns.Score)
+	}
+}
+
+func TestGetBestNode_NoNodes(t *testing.T) {
+	eng := NewEngine(defaultCfg())
+	_, _, fallback := eng.GetBestNode()
+	if !fallback {
+		t.Error("без нод должен быть fallback")
+	}
+}
+
+func TestGetBestNode_OneNode(t *testing.T) {
+	eng := NewEngine(defaultCfg())
+	eng.UpdateMetric(freshMetric("pbx-01"))
+
+	id, score, fallback := eng.GetBestNode()
+	if fallback {
+		t.Error("не должно быть fallback с одной здоровой нодой")
+	}
+	if id != "pbx-01" {
+		t.Errorf("ожидалась pbx-01, получена %s", id)
+	}
+	if score <= 0 {
+		t.Errorf("ожидался положительный score, получен %.0f", score)
+	}
+}
+
+func TestGetBestNode_AllUnhealthy(t *testing.T) {
+	eng := NewEngine(defaultCfg())
+	m1 := freshMetric("pbx-01")
+	m1.Status = "down"
+	eng.UpdateMetric(m1)
+
+	m2 := freshMetric("pbx-02")
+	m2.ActiveCalls = 500
+	m2.MaxCalls = 500
+	eng.UpdateMetric(m2)
+
+	_, _, fallback := eng.GetBestNode()
+	if !fallback {
+		t.Error("все ноды unhealthy — должен быть fallback")
+	}
+}
+
+func TestGetBestNode_MultipleNodes(t *testing.T) {
+	eng := NewEngine(defaultCfg())
+
+	// pbx-01: 80% загружена (меньше score)
+	m1 := freshMetric("pbx-01")
+	m1.ActiveCalls = 200
+	m1.MaxCalls = 250
+	eng.UpdateMetric(m1)
+
+	// pbx-02: 20% загружена (выше score)
+	m2 := freshMetric("pbx-02")
+	m2.ActiveCalls = 20
+	m2.MaxCalls = 250
+	eng.UpdateMetric(m2)
+
+	id, _, _ := eng.GetBestNode()
+	if id != "pbx-02" {
+		t.Errorf("ожидалась pbx-02 (меньше загрузки), получена %s", id)
+	}
+}
+
+func TestGetNodeHistory(t *testing.T) {
+	eng := NewEngine(defaultCfg())
+	eng.UpdateMetric(freshMetric("pbx-01"))
+
+	// Повторяем обновление для накопления истории
+	for i := 0; i < 5; i++ {
+		m := freshMetric("pbx-01")
+		m.ActiveCalls = i * 10
+		eng.UpdateMetric(m)
+	}
+
+	history := eng.GetNodeHistory("pbx-01")
+	if len(history) < 3 {
+		t.Errorf("ожидалось минимум 3 снапшота, получено %d", len(history))
+	}
+}
+
+func TestGetNodeHistory_NoNode(t *testing.T) {
+	eng := NewEngine(defaultCfg())
+	history := eng.GetNodeHistory("nonexistent")
+	if history != nil {
+		t.Error("для несуществующей ноды ожидался nil")
+	}
+}
+
+func TestToggleNode_NotFound(t *testing.T) {
+	eng := NewEngine(defaultCfg())
+	err := eng.ToggleNode("nonexistent", true, "test")
+	if err == nil {
+		t.Error("ожидалась ошибка для несуществующей ноды")
+	}
+}
+
+func TestUpdateConfig(t *testing.T) {
+	eng := NewEngine(defaultCfg())
+	m := freshMetric("pbx-01")
+	eng.UpdateMetric(m)
+
+	// Меняем конфиг на более строгий
+	newCfg := defaultCfg()
+	newCfg.Scoring.CallFailureRateLethal = 0.1
+	newCfg.Scoring.IdleCPUMin = 50
+	eng.UpdateConfig(newCfg)
+
+	ns, _ := eng.GetNodeInfo("pbx-01")
+	if ns.Score != -100 {
+		t.Errorf("после ужесточения конфига нода должна стать unhealthy, получен score=%.0f", ns.Score)
+	}
+}
+
+func TestClamp(t *testing.T) {
+	tests := []struct {
+		v, min, max, expected float64
+	}{
+		{50, 0, 100, 50},
+		{-10, 0, 100, 0},
+		{150, 0, 100, 100},
+		{0, 0, 0, 0},
+	}
+	for _, tt := range tests {
+		got := clamp(tt.v, tt.min, tt.max)
+		if got != tt.expected {
+			t.Errorf("clamp(%.0f, %.0f, %.0f) = %.0f, ожидалось %.0f",
+				tt.v, tt.min, tt.max, got, tt.expected)
+		}
+	}
+}

internal/engine/ring.go

@@ -0,0 +1,52 @@
+package engine
+
+// MetricsRingBuffer — кольцевой буфер истории метрик для одной ноды.
+// Хранит до `capacity` последних снапшотов NodeState.
+// Потокобезопасен: используется внутри Engine (защищён engine.mu).
+type MetricsRingBuffer struct {
+	buf      []NodeSnapshot
+	capacity int
+	head     int // позиция следующей записи
+	size     int // текущее количество элементов
+}
+
+// NodeSnapshot — снапшот метрик на момент времени.
+type NodeSnapshot struct {
+	ActiveCalls     int
+	MaxCalls        int
+	IdleCPU         float64
+	LoadAvg         float64
+	CallFailureRate float64
+	Score           float64
+	TS              int64
+}
+
+// newMetricsRingBuffer создаёт кольцевой буфер заданной ёмкости.
+func newMetricsRingBuffer(capacity int) *MetricsRingBuffer {
+	return &MetricsRingBuffer{
+		buf:      make([]NodeSnapshot, capacity),
+		capacity: capacity,
+	}
+}
+
+// push добавляет снапшот в буфер. Если буфер заполнен, затирает самый старый.
+func (b *MetricsRingBuffer) push(snapshot NodeSnapshot) {
+	b.buf[b.head] = snapshot
+	b.head = (b.head + 1) % b.capacity
+	if b.size < b.capacity {
+		b.size++
+	}
+}
+
+// snapshot возвращает копию всех снапшотов в хронологическом порядке.
+func (b *MetricsRingBuffer) snapshot() []NodeSnapshot {
+	result := make([]NodeSnapshot, b.size)
+	start := b.head - b.size
+	if start < 0 {
+		start += b.capacity
+	}
+	for i := 0; i < b.size; i++ {
+		result[i] = b.buf[(start+i)%b.capacity]
+	}
+	return result
+}

internal/esl/client.go

@@ -0,0 +1,377 @@
+// Package esl реализует клиент FreeSWITCH Event Socket Library (ESL).
+// Использует сырой TCP — протокол ESL прост (HTTP-подобные заголовки +
+// Content-Length тело), не нужна внешняя библиотека.
+//
+// Клиент обеспечивает:
+//   - Подключение и аутентификацию
+//   - Синхронные команды (api)
+//   - Подписку на события
+//   - Автоматический реконнект с exponential backoff
+//   - Потокобезопасность (mutex на отправку команд)
+package esl
+
+import (
+	"bufio"
+	"fmt"
+	"io"
+	"log"
+	"net"
+	"strconv"
+	"strings"
+	"sync"
+	"sync/atomic"
+	"time"
+)
+
+// Event — событие, полученное от FreeSWITCH ESL.
+type Event struct {
+	Name    string
+	Headers map[string]string
+	Body    string
+}
+
+// Client — ESL-клиент для управления FreeSWITCH.
+type Client struct {
+	host     string
+	port     int
+	password string
+
+	conn   net.Conn
+	reader *bufio.Reader
+	mu     sync.Mutex // защищает отправку команд
+
+	connected atomic.Bool
+	eventsCh  chan *Event
+	closeCh   chan struct{}
+
+	// Переподключение
+	shouldReconn atomic.Bool
+	backoff      time.Duration
+
+	// Статистика
+	reconnects   atomic.Int64
+	gatewayOps   atomic.Int64
+	eventsRecv   atomic.Int64
+	startTime    time.Time
+}
+
+// NewClient создаёт нового ESL-клиента.
+func NewClient(host string, port int, password string) *Client {
+	return &Client{
+		host:     host,
+		port:     port,
+		password: password,
+		eventsCh: make(chan *Event, 100),
+		closeCh:  make(chan struct{}),
+		backoff:  1 * time.Second,
+	}
+}
+
+// Connect подключается к FreeSWITCH и запускает фоновый реконнект.
+// Блокируется до первой успешной аутентификации.
+func (c *Client) Connect() error {
+	c.shouldReconn.Store(true)
+	if err := c.tryConnect(); err != nil {
+		return fmt.Errorf("esl connect: %w", err)
+	}
+	return nil
+}
+
+// ConnectWithRetry подключается в фоне с бесконечными попытками.
+func (c *Client) ConnectWithRetry() {
+	c.shouldReconn.Store(true)
+	for {
+		err := c.tryConnect()
+		if err == nil {
+			return // успех
+		}
+		if !c.shouldReconn.Load() {
+			return // остановка
+		}
+		log.Printf("[esl] ошибка подключения: %v, повтор через %v", err, c.backoff)
+		time.Sleep(c.backoff)
+		c.backoff *= 2
+		if c.backoff > 60*time.Second {
+			c.backoff = 60 * time.Second
+		}
+	}
+}
+
+// tryConnect выполняет одну попытку подключения и аутентификации.
+func (c *Client) tryConnect() error {
+	c.mu.Lock()
+	defer c.mu.Unlock()
+
+	// Закрываем предыдущее соединение если было
+	if c.conn != nil {
+		c.conn.Close()
+		c.closeCh = make(chan struct{})
+	}
+
+	addr := fmt.Sprintf("%s:%d", c.host, c.port)
+	dialer := net.Dialer{Timeout: 5 * time.Second}
+	conn, err := dialer.Dial("tcp", addr)
+	if err != nil {
+		return fmt.Errorf("dial %s: %w", addr, err)
+	}
+	c.conn = conn
+	c.reader = bufio.NewReader(conn)
+
+	// 1. Читаем auth/request
+	headers, _, err := c.readMessageLocked()
+	if err != nil {
+		conn.Close()
+		return fmt.Errorf("чтение auth/request: %w", err)
+	}
+	if headers["Content-Type"] != "auth/request" {
+		conn.Close()
+		return fmt.Errorf("ожидался auth/request, получен %s", headers["Content-Type"])
+	}
+
+	// 2. Отправляем пароль
+	authCmd := fmt.Sprintf("auth %s\n\n", c.password)
+	if _, err := conn.Write([]byte(authCmd)); err != nil {
+		conn.Close()
+		return fmt.Errorf("отправка auth: %w", err)
+	}
+
+	// 3. Читаем auth response
+	headers, _, err = c.readMessageLocked()
+	if err != nil {
+		conn.Close()
+		return fmt.Errorf("чтение auth response: %w", err)
+	}
+	if reply := headers["Reply-Text"]; !strings.HasPrefix(reply, "+OK") {
+		conn.Close()
+		return fmt.Errorf("auth rejected: %s", reply)
+	}
+
+	c.connected.Store(true)
+	c.startTime = time.Now()
+	c.backoff = 1 * time.Second // сброс backoff после успешного коннекта
+
+	endpoint := fmt.Sprintf("%s:%d", c.host, c.port)
+	log.Printf("[esl] подключён к %s", endpoint)
+
+	return nil
+}
+
+// Disconnect отключает клиент и останавливает реконнект.
+func (c *Client) Disconnect() {
+	c.shouldReconn.Store(false)
+	c.mu.Lock()
+	defer c.mu.Unlock()
+	c.connected.Store(false)
+	if c.conn != nil {
+		c.conn.Close()
+		c.conn = nil
+	}
+	close(c.closeCh)
+}
+
+// IsConnected возвращает статус подключения.
+func (c *Client) IsConnected() bool {
+	return c.connected.Load()
+}
+
+// Send отправляет синхронную команду и возвращает тело ответа.
+// Пример: Send("api sofia profile external gwlist") → список gateway.
+func (c *Client) Send(command string) (map[string]string, string, error) {
+	c.mu.Lock()
+	defer c.mu.Unlock()
+
+	if !c.connected.Load() || c.conn == nil {
+		return nil, "", fmt.Errorf("esl не подключён")
+	}
+
+	// Отправляем команду
+	fullCmd := command + "\n\n"
+	if _, err := c.conn.Write([]byte(fullCmd)); err != nil {
+		c.connected.Store(false)
+		return nil, "", fmt.Errorf("отправка команды: %w", err)
+	}
+
+	// Читаем ответ
+	return c.readMessageLocked()
+}
+
+// Subscribe подписывается на события ESL.
+// events — имена событий для фильтра: "SOFIA::gateway_register SOFIA::gateway_unregister".
+func (c *Client) Subscribe(events string) error {
+	cmd := fmt.Sprintf("event plain %s", events)
+	_, _, err := c.Send(cmd)
+	if err != nil {
+		return fmt.Errorf("подписка на события: %w", err)
+	}
+	log.Printf("[esl] подписан на события: %s", events)
+	return nil
+}
+
+// Events возвращает канал с входящими событиями.
+func (c *Client) Events() <-chan *Event {
+	return c.eventsCh
+}
+
+// StartReadingEvents запускает горутину чтения асинхронных событий FS.
+// Должна вызываться после Connect().
+func (c *Client) StartReadingEvents() {
+	if !c.shouldReconn.Load() {
+		return
+	}
+	go c.readEventsLoop()
+}
+
+// readEventsLoop читает асинхронные сообщения (события) от FS.
+func (c *Client) readEventsLoop() {
+	for {
+		select {
+		case <-c.closeCh:
+			return
+		default:
+		}
+
+		if !c.connected.Load() || c.conn == nil {
+			time.Sleep(500 * time.Millisecond)
+			continue
+		}
+
+		c.mu.Lock()
+		headers, body, err := c.readMessageLocked()
+		c.mu.Unlock()
+
+		if err != nil {
+			if err == io.EOF || strings.Contains(err.Error(), "use of closed network connection") {
+				c.connected.Store(false)
+				log.Printf("[esl] соединение разорвано, реконнект...")
+				c.reconnects.Add(1)
+				c.reconnect()
+				continue
+			}
+			log.Printf("[esl] ошибка чтения события: %v", err)
+			time.Sleep(100 * time.Millisecond)
+			continue
+		}
+
+		eventName := headers["Event-Name"]
+		if eventName == "" {
+			continue // не событие (например, ответ на команду)
+		}
+
+		evt := &Event{
+			Name:    eventName,
+			Headers: headers,
+			Body:    body,
+		}
+		c.eventsRecv.Add(1)
+
+		select {
+		case c.eventsCh <- evt:
+		default:
+			log.Printf("[esl] канал событий переполнен, пропускаем %s", eventName)
+		}
+	}
+}
+
+// reconnect выполняет реконнект с backoff.
+func (c *Client) reconnect() {
+	if !c.shouldReconn.Load() {
+		return
+	}
+	log.Printf("[esl] реконнект через %v...", c.backoff)
+	time.Sleep(c.backoff)
+
+	c.mu.Lock()
+	if c.conn != nil {
+		c.conn.Close()
+		c.conn = nil
+	}
+	c.mu.Unlock()
+
+	if err := c.tryConnect(); err != nil {
+		log.Printf("[esl] реконнект не удался: %v", err)
+		c.backoff *= 2
+		if c.backoff > 60*time.Second {
+			c.backoff = 60 * time.Second
+		}
+		return
+	}
+
+	// Успешный реконнект
+	c.backoff = 1 * time.Second
+	log.Printf("[esl] реконнект успешен, переподписываемся на события")
+	// TODO: gatewaySyncAll() и resubscribe на события вызываются снаружи
+}
+
+// --- Приватные методы ---
+
+// readMessageLocked читает одно ESL-сообщение: заголовки + тело.
+// Вызывающий держит c.mu.
+func (c *Client) readMessageLocked() (map[string]string, string, error) {
+	headers := make(map[string]string)
+
+	for {
+		line, err := c.reader.ReadString('\n')
+		if err != nil {
+			return nil, "", err
+		}
+		line = strings.TrimRight(line, "\r\n")
+		if line == "" {
+			break // конец заголовков
+		}
+
+		parts := strings.SplitN(line, ":", 2)
+		if len(parts) == 2 {
+			headers[strings.TrimSpace(parts[0])] = strings.TrimSpace(parts[1])
+		}
+	}
+
+	// Читаем тело согласно Content-Length
+	cl := headers["Content-Length"]
+	if cl == "" {
+		return headers, "", nil
+	}
+	length, err := strconv.Atoi(cl)
+	if err != nil {
+		return headers, "", fmt.Errorf("некорректный Content-Length: %s", cl)
+	}
+
+	body := make([]byte, length)
+	if _, err := io.ReadFull(c.reader, body); err != nil {
+		return headers, "", fmt.Errorf("чтение тела (Content-Length=%d): %w", length, err)
+	}
+
+	return headers, strings.TrimSpace(string(body)), nil
+}
+
+// --- Метрики ---
+
+// Stats возвращает статистику ESL-клиента для health endpoint.
+type Stats struct {
+	Status       string `json:"status"`
+	Host         string `json:"host"`
+	Reconnects   int64  `json:"reconnects"`
+	GatewayOps   int64  `json:"gateway_ops_total"`
+	EventsRecv   int64  `json:"events_received"`
+	UptimeSec    int64  `json:"uptime_seconds"`
+}
+
+// GetStats возвращает текущую статистику.
+func (c *Client) GetStats() Stats {
+	st := "connected"
+	if !c.connected.Load() {
+		st = "disconnected"
+	}
+	return Stats{
+		Status:     st,
+		Host:       fmt.Sprintf("%s:%d", c.host, c.port),
+		Reconnects: c.reconnects.Load(),
+		GatewayOps: c.gatewayOps.Load(),
+		EventsRecv: c.eventsRecv.Load(),
+		UptimeSec:  int64(time.Since(c.startTime).Seconds()),
+	}
+}
+
+// IncGatewayOps увеличивает счётчик операций gateway.
+func (c *Client) IncGatewayOps() {
+	c.gatewayOps.Add(1)
+}

internal/esl/events.go

@@ -0,0 +1,91 @@
+package esl
+
+import (
+	"context"
+	"log"
+	"time"
+)
+
+// EventHandler — callback для обработки событий ESL.
+// Принимает имя события и заголовки, вызывается из readEventsLoop.
+type EventHandler func(eventName string, headers map[string]string, body string)
+
+// StartEventLoop запускает основной цикл реконнекта и чтения событий.
+// При успешном подключении:
+//   - Вызывает onConnect (например, для GatewaySyncAll)
+//   - Подписывается на события SOFIA::gateway_register/unregister
+//   - Запускает чтение асинхронных событий
+// При разрыве соединения — автоматический реконнект.
+func (c *Client) StartEventLoop(ctx context.Context, profile string, onConnect func(), onEvent EventHandler) {
+	const subscribeEvents = "SOFIA::gateway_register SOFIA::gateway_unregister SOFIA::gateway_expire"
+
+	go func() {
+		for {
+			select {
+			case <-ctx.Done():
+				c.Disconnect()
+				return
+			default:
+			}
+
+			// Пытаемся подключиться
+			log.Printf("[esl] попытка подключения к %s:%d", c.host, c.port)
+			if err := c.Connect(); err != nil {
+				log.Printf("[esl] ошибка подключения: %v, повтор через %v", err, c.backoff)
+				time.Sleep(c.backoff)
+				c.backoff *= 2
+				if c.backoff > 60*time.Second {
+					c.backoff = 60 * time.Second
+				}
+				continue
+			}
+
+			// Успешное подключение
+			c.backoff = 1 * time.Second
+
+			// Подписываемся на события
+			if err := c.Subscribe(subscribeEvents); err != nil {
+				log.Printf("[esl] ошибка подписки: %v", err)
+				c.Disconnect()
+				continue
+			}
+
+			// Вызываем callback (GatewaySyncAll)
+			if onConnect != nil {
+				onConnect()
+			}
+
+			// Читаем события пока соединение живо
+			readEvents := make(chan struct{})
+			go func() {
+				defer close(readEvents)
+				c.readEventsLoop()
+				// Не ждём реконнект внутри readEventsLoop
+			}()
+
+			// Основной цикл обработки событий
+			for {
+				select {
+				case <-ctx.Done():
+					c.Disconnect()
+					return
+				case <-readEvents:
+					// Соединение разорвалось — идём на реконнект
+					log.Printf("[esl] чтение событий остановлено")
+					goto reconnect
+				case evt, ok := <-c.Events():
+					if !ok {
+						goto reconnect
+					}
+					if onEvent != nil {
+						onEvent(evt.Name, evt.Headers, evt.Body)
+					}
+				}
+			}
+
+		reconnect:
+			c.Disconnect()
+			time.Sleep(c.backoff)
+		}
+	}()
+}

internal/esl/gateway.go

@@ -0,0 +1,107 @@
+package esl
+
+import (
+	"fmt"
+	"log"
+	"strings"
+)
+
+// GatewayAdd создаёт gateway на FreeSWITCH через Sofia профиль.
+// Возвращает nil если gateway создан или уже существует (идемпотентность).
+func (c *Client) GatewayAdd(profile, name, proxy string) error {
+	cmd := fmt.Sprintf("api sofia profile %s gwadd %s %s", profile, name, proxy)
+	headers, body, err := c.Send(cmd)
+	c.IncGatewayOps()
+
+	if err != nil {
+		log.Printf("[esl] GatewayAdd %s: ошибка команды: %v", name, err)
+		return err
+	}
+
+	reply := headers["Reply-Text"]
+	if strings.HasPrefix(reply, "+OK") {
+		log.Printf("[esl] GatewayAdd %s: создан (%s → %s)", name, profile, proxy)
+		return nil
+	}
+
+	// Gateway уже существует — не ошибка
+	if strings.Contains(body, "GATEWAY ALREADY") || strings.Contains(reply, "GATEWAY ALREADY") {
+		log.Printf("[esl] GatewayAdd %s: уже существует, ок", name)
+		return nil
+	}
+
+	log.Printf("[esl] GatewayAdd %s: ошибка FS — Reply: %s, Body: %s", name, reply, body)
+	return fmt.Errorf("GatewayAdd %s: %s (%s)", name, reply, body)
+}
+
+// GatewayDelete удаляет gateway на FreeSWITCH.
+// Возвращает nil если gateway удалён или не найден (идемпотентность).
+func (c *Client) GatewayDelete(profile, name string) error {
+	cmd := fmt.Sprintf("api sofia profile %s gwdel %s", profile, name)
+	headers, body, err := c.Send(cmd)
+	c.IncGatewayOps()
+
+	if err != nil {
+		log.Printf("[esl] GatewayDelete %s: ошибка команды: %v", name, err)
+		return err
+	}
+
+	reply := headers["Reply-Text"]
+	if strings.HasPrefix(reply, "+OK") {
+		log.Printf("[esl] GatewayDelete %s: удалён", name)
+		return nil
+	}
+
+	// Gateway не найден — не ошибка
+	if strings.Contains(body, "GATEWAY NOT FOUND") || strings.Contains(reply, "GATEWAY NOT FOUND") {
+		log.Printf("[esl] GatewayDelete %s: не найден, ок", name)
+		return nil
+	}
+
+	log.Printf("[esl] GatewayDelete %s: ошибка FS — Reply: %s, Body: %s", name, reply, body)
+	return fmt.Errorf("GatewayDelete %s: %s (%s)", name, reply, body)
+}
+
+// GatewayList возвращает список имён gateway в заданном профиле.
+func (c *Client) GatewayList(profile string) ([]string, error) {
+	cmd := fmt.Sprintf("api sofia profile %s gwlist", profile)
+	_, body, err := c.Send(cmd)
+
+	if err != nil {
+		return nil, fmt.Errorf("GatewayList: %w", err)
+	}
+
+	// Парсим вывод gwlist — имена gateway на отдельных строках
+	lines := strings.Split(body, "\n")
+	var gateways []string
+	for _, line := range lines {
+		line = strings.TrimSpace(line)
+		if line == "" || strings.HasPrefix(line, "Name:") || strings.HasPrefix(line, "====") {
+			continue
+		}
+		// Ищем строки вида "pulse-ingress-xxxxx      sip:..."
+		if strings.Contains(line, "pulse-") {
+			parts := strings.Fields(line)
+			if len(parts) > 0 {
+				gateways = append(gateways, parts[0])
+			}
+		}
+	}
+	return gateways, nil
+}
+
+// GatewaySyncAll синхронизирует все ingress-транки как gateway на FS.
+// Вызывается после реконнекта.
+func (c *Client) GatewaySyncAll(profile string, gateways []GatewaySpec) {
+	for _, g := range gateways {
+		if err := c.GatewayAdd(profile, g.Name, g.Proxy); err != nil {
+			log.Printf("[esl] GatewaySyncAll: ошибка %s: %v", g.Name, err)
+		}
+	}
+}
+
+// GatewaySpec описывает gateway для синхронизации.
+type GatewaySpec struct {
+	Name  string
+	Proxy string
+}

internal/log/logger.go

@@ -0,0 +1,93 @@
+// Package log реализует ASCII-логгер метрик с ротацией по дням.
+// Формат: "2026-06-25T10:00:00Z pbx-01 calls=42 load=0.85 idle_cpu=35 fail=0.5 score=73"
+package log
+
+import (
+	"fmt"
+	"os"
+	"path/filepath"
+	"strings"
+	"sync"
+	"time"
+
+	"github.com/pulse-lets-go/internal/models"
+)
+
+// Logger — потокобезопасный логгер метрик в ASCII-файл с дневной ротацией.
+type Logger struct {
+	mu     sync.Mutex
+	dir    string
+	file   *os.File
+	today  string // YYYY-MM-DD последнего открытого файла
+}
+
+// NewLogger создаёт логгер, записывающий в dataDir/.
+// Файлы именуются как metrics.YYYY-MM-DD.log.
+func NewLogger(dataDir string) (*Logger, error) {
+	if err := os.MkdirAll(dataDir, 0750); err != nil {
+		return nil, fmt.Errorf("создание data/: %w", err)
+	}
+	l := &Logger{dir: dataDir}
+	if err := l.ensureFile(); err != nil {
+		return nil, err
+	}
+	return l, nil
+}
+
+// Log записывает снапшот метрик ноды в лог-файл.
+func (l *Logger) Log(ns *models.NodeState) {
+	l.mu.Lock()
+	defer l.mu.Unlock()
+
+	if err := l.ensureFile(); err != nil {
+		return // тихая ошибка — не блокируем метрики из-за логгера
+	}
+
+	line := l.formatLine(ns)
+	l.file.WriteString(line + "\n")
+}
+
+// formatLine форматирует строку лога.
+func (l *Logger) formatLine(ns *models.NodeState) string {
+	t := time.Unix(ns.TS, 0).UTC().Format(time.RFC3339)
+	return fmt.Sprintf("%s %s calls=%d load=%.2f idle_cpu=%.1f fail=%.1f score=%.1f disabled=%t",
+		t, ns.NodeID, ns.ActiveCalls, ns.LoadAvg, ns.IdleCPU, ns.CallFailureRate, ns.Score, ns.Disabled)
+}
+
+// Close закрывает файл лога.
+func (l *Logger) Close() error {
+	l.mu.Lock()
+	defer l.mu.Unlock()
+	if l.file != nil {
+		return l.file.Close()
+	}
+	return nil
+}
+
+// ensureFile открывает файл на текущий день, создавая новый, если день сменился.
+// Вызывающий держит mu.
+func (l *Logger) ensureFile() error {
+	today := time.Now().UTC().Format("2006-01-02")
+	if l.file != nil && l.today == today {
+		return nil
+	}
+
+	if l.file != nil {
+		l.file.Close()
+	}
+
+	path := filepath.Join(l.dir, "metrics."+today+".log")
+	f, err := os.OpenFile(path, os.O_APPEND|os.O_CREATE|os.O_WRONLY, 0640)
+	if err != nil {
+		return fmt.Errorf("открытие лог-файла %s: %w", path, err)
+	}
+
+	l.file = f
+	l.today = today
+	return nil
+}
+
+// TrimPrefix обрезает "metrics." и ".log" из имени файла (для API истории).
+func TrimPrefix(filename string) string {
+	return strings.TrimPrefix(strings.TrimSuffix(filename, ".log"), "metrics.")
+}

internal/models/types.go

@@ -0,0 +1,217 @@
+// Package models содержит общие типы данных pulse-lets-go.
+package models
+
+import "time"
+
+// --- NATS: метрика от нижестоящей АТС ---
+
+// NodeMetric — сообщение, публикуемое нодой в NATS каждые 5 сек.
+type NodeMetric struct {
+	NodeID           string  `json:"node_id"`
+	TS               int64   `json:"ts"`                 // unix timestamp
+	Status           string  `json:"status"`             // "ok", "degraded", "down"
+	ActiveCalls      int     `json:"active_calls"`
+	MaxCalls         int     `json:"max_calls"`
+	IdleCPU          float64 `json:"idle_cpu"`           // 0..100 %
+	LoadAvg          float64 `json:"load_avg"`           // system load average (1m)
+	CallFailureRate  float64 `json:"call_failure_rate"`  // 0.0..100.0 %
+}
+
+// --- In-memory состояние ноды в engine ---
+
+// NodeState — полное состояние ноды в памяти балансировщика.
+// Содержит данные последней метрики + поля ручного управления.
+type NodeState struct {
+	NodeMetric
+	Disabled       bool   `json:"disabled"`
+	DisabledReason string `json:"disabled_reason"`
+	Score          float64 `json:"score"`
+	LethalReason   string  `json:"lethal_reason,omitempty"` // причина, если score = -100
+}
+
+// --- Trunk ---
+
+// TrunkType — тип транка.
+type TrunkType string
+
+const (
+	TrunkIngress  TrunkType = "ingress"
+	TrunkBalance  TrunkType = "balance"
+	TrunkFallback TrunkType = "fallback"
+)
+
+// Trunk — модель транка (из trunks.json).
+type Trunk struct {
+	ID          string    `json:"id"`
+	Name        string    `json:"name"`
+	Type        TrunkType `json:"type"`
+	NodeID      string    `json:"node_id,omitempty"`    // только для balance
+	Gateway     string    `json:"gateway"`
+	Codecs      []string  `json:"codecs,omitempty"`
+	Context     string    `json:"context,omitempty"`
+	Enabled     bool      `json:"enabled"`
+	Description string    `json:"description,omitempty"`
+	CreatedAt   time.Time `json:"created_at"`
+	UpdatedAt   time.Time `json:"updated_at"`
+}
+
+// --- User ---
+
+// UserRole — роль пользователя.
+type UserRole string
+
+const (
+	RoleAdmin  UserRole = "admin"
+	RoleViewer UserRole = "viewer"
+)
+
+// User — модель пользователя (из users.json).
+type User struct {
+	ID           string   `json:"id"`
+	Username     string   `json:"username"`
+	PasswordHash string   `json:"password_hash"`
+	Role         UserRole `json:"role"`
+	CreatedAt    time.Time `json:"created_at"`
+	UpdatedAt    time.Time `json:"updated_at"`
+}
+
+// --- Auth ---
+
+// LoginRequest — тело запроса на /api/auth/login.
+type LoginRequest struct {
+	Username string `json:"username"`
+	Password string `json:"password"`
+}
+
+// LoginResponse — тело ответа /api/auth/login.
+type LoginResponse struct {
+	AccessToken  string `json:"access_token"`
+	RefreshToken string `json:"refresh_token"`
+	ExpiresIn    int64  `json:"expires_in"`
+}
+
+// --- /api/route ---
+
+// RouteResponse — ответ на запрос маршрутизации.
+type RouteResponse struct {
+	// Успех
+	NodeID      string  `json:"node_id,omitempty"`
+	Score       float64 `json:"score,omitempty"`
+	SIPGateway  string  `json:"sip_gateway,omitempty"`
+
+	// Fallback
+	Fallback    bool   `json:"fallback,omitempty"`
+	Reason      string `json:"reason,omitempty"`
+
+	// Общая информация о нодах
+	Nodes       []RouteNodeInfo `json:"nodes,omitempty"`
+
+	// Ошибка
+	Error       string `json:"error,omitempty"`
+}
+
+// RouteNodeInfo — информация о ноде в ответе маршрутизации.
+type RouteNodeInfo struct {
+	ID     string  `json:"id"`
+	Score  float64 `json:"score"`
+	Reason string `json:"reason,omitempty"`
+	Status string `json:"status"`
+}
+
+// --- API: Nodes ---
+
+// ToggleNodeRequest — запрос на включение/выключение ноды.
+type ToggleNodeRequest struct {
+	Disabled bool   `json:"disabled"`
+	Reason   string `json:"reason,omitempty"`
+}
+
+// NodeInfo — информация о ноде для фронта.
+type NodeInfo struct {
+	NodeID         string  `json:"node_id"`
+	TS             int64   `json:"ts"`
+	Status         string  `json:"status"`
+	ActiveCalls    int     `json:"active_calls"`
+	MaxCalls       int     `json:"max_calls"`
+	IdleCPU        float64 `json:"idle_cpu"`
+	LoadAvg        float64 `json:"load_avg"`
+	CallFailureRate float64 `json:"call_failure_rate"`
+	Disabled       bool    `json:"disabled"`
+	DisabledReason string  `json:"disabled_reason,omitempty"`
+	Score          float64 `json:"score"`
+	LethalReason   string  `json:"lethal_reason,omitempty"`
+	IsStale        bool    `json:"is_stale"`
+	SecondsAgo     float64 `json:"seconds_ago"`
+}
+
+// --- API: Users ---
+
+// CreateUserRequest — запрос на создание пользователя.
+type CreateUserRequest struct {
+	Username string   `json:"username"`
+	Password string   `json:"password"`
+	Role     UserRole `json:"role"`
+}
+
+// UpdateUserRequest — запрос на обновление пользователя.
+type UpdateUserRequest struct {
+	Username *string   `json:"username,omitempty"`
+	Password *string   `json:"password,omitempty"`
+	Role     *UserRole `json:"role,omitempty"`
+}
+
+// --- API: Trunks ---
+
+// CreateTrunkRequest — запрос на создание транка.
+type CreateTrunkRequest struct {
+	Name        string    `json:"name"`
+	Type        TrunkType `json:"type"`
+	NodeID      string    `json:"node_id,omitempty"`
+	Gateway     string    `json:"gateway"`
+	Codecs      []string  `json:"codecs,omitempty"`
+	Context     string    `json:"context,omitempty"`
+	Enabled     bool      `json:"enabled"`
+	Description string    `json:"description,omitempty"`
+}
+
+// UpdateTrunkRequest — запрос на обновление транка.
+type UpdateTrunkRequest struct {
+	Name        *string    `json:"name,omitempty"`
+	Type        *TrunkType `json:"type,omitempty"`
+	NodeID      *string    `json:"node_id,omitempty"`
+	Gateway     *string    `json:"gateway,omitempty"`
+	Codecs      []string   `json:"codecs,omitempty"`
+	Context     *string    `json:"context,omitempty"`
+	Enabled     *bool      `json:"enabled,omitempty"`
+	Description *string    `json:"description,omitempty"`
+}
+
+// --- Monitoring ---
+
+// ZabbixNode — элемент LLD (Low-Level Discovery) для Zabbix.
+type ZabbixNode struct {
+	NodeID         string  `json:"{#NODE_ID}"`
+	Status         string  `json:"{#STATUS}"`
+	ActiveCalls    int     `json:"{#ACTIVE_CALLS}"`
+	MaxCalls       int     `json:"{#MAX_CALLS}"`
+	IdleCPU        float64 `json:"{#IDLE_CPU}"`
+	LoadAvg        float64 `json:"{#LOAD_AVG}"`
+	CallFailureRate float64 `json:"{#CALL_FAILURE_RATE}"`
+	Score          float64 `json:"{#SCORE}"`
+	Disabled       bool    `json:"{#DISABLED}"`
+	IsStale        bool    `json:"{#IS_STALE}"`
+	SecondsAgo     float64 `json:"{#SECONDS_AGO}"`
+}
+
+// ZabbixResponse — ответ на запрос Zabbix LLD.
+type ZabbixResponse struct {
+	Data []ZabbixNode `json:"data"`
+}
+
+// --- WebSocket ---
+
+// WsMetricsMessage — сообщение, отправляемое по WebSocket.
+type WsMetricsMessage struct {
+	Type    string      `json:"type"`    // "nodes_update", "node_toggle", etc
+	Payload interface{} `json:"payload"`
+}

internal/nats/subscriber.go

@@ -0,0 +1,98 @@
+// Package nats содержит подписчика на NATS-метрики от нижестоящих АТС.
+package nats
+
+import (
+	"encoding/json"
+	"fmt"
+	"log"
+	"sync"
+
+	natsgo "github.com/nats-io/nats.go"
+
+	"github.com/pulse-lets-go/internal/models"
+	"github.com/pulse-lets-go/internal/engine"
+	filelog "github.com/pulse-lets-go/internal/log"
+)
+
+const subject = "pulse.metrics.>"
+
+// Subscriber подписывается на NATS и обновляет engine + пишет лог.
+type Subscriber struct {
+	nc     *natsgo.Conn
+	sub    *natsgo.Subscription
+	engine *engine.Engine
+	logger *filelog.Logger
+	wg     sync.WaitGroup
+}
+
+// NewSubscriber подключается к NATS и запускает подписку.
+func NewSubscriber(natsURL, user, password string, eng *engine.Engine, l *filelog.Logger) (*Subscriber, error) {
+	opts := []natsgo.Option{
+		natsgo.ReconnectWait(natsgo.DefaultReconnectWait),
+		natsgo.MaxReconnects(-1),
+	}
+	if user != "" && password != "" {
+		opts = append(opts, natsgo.UserInfo(user, password))
+	}
+
+	nc, err := natsgo.Connect(natsURL, opts...)
+	if err != nil {
+		return nil, fmt.Errorf("nats connect: %w", err)
+	}
+
+	s := &Subscriber{
+		nc:     nc,
+		engine: eng,
+		logger: l,
+	}
+
+	sub, err := nc.Subscribe(subject, s.handleMetric)
+	if err != nil {
+		nc.Close()
+		return nil, fmt.Errorf("nats subscribe: %w", err)
+	}
+	s.sub = sub
+
+	log.Printf("[nats] подписан на %s, подключён к %s", subject, natsURL)
+	return s, nil
+}
+
+// handleMetric — обработчик входящих сообщений NATS.
+func (s *Subscriber) handleMetric(msg *natsgo.Msg) {
+	var metric models.NodeMetric
+	if err := json.Unmarshal(msg.Data, &metric); err != nil {
+		log.Printf("[nats] ошибка парсинга метрики: %v", err)
+		return
+	}
+
+	// Валидация минимальных полей
+	if metric.NodeID == "" {
+		log.Printf("[nats] метрика без node_id, игнорируется")
+		return
+	}
+	if metric.MaxCalls <= 0 {
+		metric.MaxCalls = 250 // разумное значение по умолчанию
+	}
+
+	ns := s.engine.UpdateMetric(&metric)
+	s.logger.Log(ns)
+}
+
+// IsConnected возвращает true, если NATS-соединение активно.
+func (s *Subscriber) IsConnected() bool {
+	if s.nc == nil {
+		return false
+	}
+	return s.nc.IsConnected()
+}
+
+// Close останавливает подписку и закрывает соединение.
+func (s *Subscriber) Close() {
+	if s.sub != nil {
+		s.sub.Unsubscribe()
+	}
+	if s.nc != nil {
+		s.nc.Close()
+	}
+	s.wg.Wait()
+}

web/package.json

@@ -0,0 +1,26 @@
+{
+  "name": "pulse-lets-go-web",
+  "version": "1.0.0",
+  "private": true,
+  "type": "module",
+  "scripts": {
+    "dev": "vite dev --port 5173",
+    "build": "vite build",
+    "preview": "vite preview"
+  },
+  "devDependencies": {
+    "@sveltejs/adapter-static": "^3.0.0",
+    "@sveltejs/kit": "^2.60.0",
+    "@sveltejs/vite-plugin-svelte": "^5.0.0",
+    "svelte": "^5.50.0",
+    "tailwindcss": "^4.3.0",
+    "@tailwindcss/vite": "^4.3.0",
+    "typescript": "^5.7.0"
+  },
+  "dependencies": {
+    "clsx": "^2.1.0",
+    "lucide-svelte": "^1.0.0",
+    "svelte-sonner": "^1.0.0",
+    "tailwind-merge": "^3.0.0"
+  }
+}

web/src/app.css

@@ -0,0 +1,29 @@
+@import 'tailwindcss';
+
+@theme {
+  --color-background: oklch(0.98 0 0);
+  --color-foreground: oklch(0.15 0 0);
+  --color-card: oklch(1 0 0);
+  --color-card-foreground: oklch(0.15 0 0);
+  --color-primary: oklch(0.55 0.2 260);
+  --color-primary-foreground: oklch(0.98 0 0);
+  --color-secondary: oklch(0.96 0 0);
+  --color-secondary-foreground: oklch(0.15 0 0);
+  --color-muted: oklch(0.96 0 0);
+  --color-muted-foreground: oklch(0.5 0 0);
+  --color-destructive: oklch(0.55 0.2 25);
+  --color-destructive-foreground: oklch(0.98 0 0);
+  --color-border: oklch(0.9 0 0);
+  --color-ring: oklch(0.55 0.2 260);
+  --radius: 0.5rem;
+}
+
+body {
+  font-family: system-ui, -apple-system, sans-serif;
+}
+
+@layer base {
+  * {
+    border-color: var(--color-border);
+  }
+}

web/src/app.html

@@ -0,0 +1,13 @@
+<!doctype html>
+<html lang="ru">
+  <head>
+    <meta charset="utf-8" />
+    <meta name="viewport" content="width=device-width, initial-scale=1" />
+    <link rel="icon" href="data:image/svg+xml,<svg xmlns='http://www.w3.org/2000/svg' viewBox='0 0 100 100'><text y='.9em' font-size='90'>📞</text></svg>" />
+    <title>pulse-lets-go</title>
+    %sveltekit.head%
+  </head>
+  <body class="min-h-screen bg-background text-foreground">
+    %sveltekit.body%
+  </body>
+</html>

web/src/lib/api.ts

@@ -0,0 +1,209 @@
+// API client для pulse-lets-go backend.
+const API_BASE = '/api';
+
+function getToken(): string | null {
+  if (typeof localStorage === 'undefined') return null;
+  return localStorage.getItem('token');
+}
+
+function getRefreshToken(): string | null {
+  if (typeof localStorage === 'undefined') return null;
+  return localStorage.getItem('refreshToken');
+}
+
+async function refreshAccessToken(): Promise<string | null> {
+  const refresh = getRefreshToken();
+  if (!refresh) return null;
+
+  try {
+    const res = await fetch(`${API_BASE}/auth/refresh`, {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json', 'Authorization': `Bearer ${refresh}` },
+    });
+    if (!res.ok) return null;
+
+    const data = await res.json();
+    localStorage.setItem('token', data.access_token);
+    localStorage.setItem('refreshToken', data.refresh_token);
+    return data.access_token;
+  } catch {
+    return null;
+  }
+}
+
+async function request<T>(url: string, options: RequestInit = {}): Promise<T> {
+  let token = getToken();
+  const headers: Record<string, string> = {
+    'Content-Type': 'application/json',
+    ...(options.headers as Record<string, string>),
+  };
+
+  if (token) {
+    headers['Authorization'] = `Bearer ${token}`;
+  }
+
+  let res = await fetch(`${API_BASE}${url}`, { ...options, headers });
+
+  // Пробуем обновить токен при 401
+  if (res.status === 401 && token) {
+    const newToken = await refreshAccessToken();
+    if (newToken) {
+      headers['Authorization'] = `Bearer ${newToken}`;
+      res = await fetch(`${API_BASE}${url}`, { ...options, headers });
+    }
+  }
+
+  if (res.status === 204) return undefined as T;
+  if (!res.ok) {
+    const err = await res.json().catch(() => ({ error: res.statusText }));
+    throw new Error(err.error || 'API error');
+  }
+
+  return res.json();
+}
+
+// --- Auth ---
+export async function login(username: string, password: string) {
+  const data = await request<{ access_token: string; refresh_token: string; expires_in: number }>(
+    '/auth/login',
+    { method: 'POST', body: JSON.stringify({ username, password }) }
+  );
+  localStorage.setItem('token', data.access_token);
+  localStorage.setItem('refreshToken', data.refresh_token);
+  return data;
+}
+
+export function isAuthenticated(): boolean {
+  return !!getToken();
+}
+
+export function logout() {
+  localStorage.removeItem('token');
+  localStorage.removeItem('refreshToken');
+  window.location.href = '/login';
+}
+
+// --- Nodes ---
+export interface NodeInfo {
+  node_id: string;
+  ts: number;
+  status: string;
+  active_calls: number;
+  max_calls: number;
+  idle_cpu: number;
+  load_avg: number;
+  call_failure_rate: number;
+  disabled: boolean;
+  disabled_reason: string;
+  score: number;
+  lethal_reason: string;
+  is_stale: boolean;
+  seconds_ago: number;
+}
+
+export async function getNodes(): Promise<NodeInfo[]> {
+  return request<NodeInfo[]>('/nodes');
+}
+
+export async function toggleNode(nodeId: string, disabled: boolean, reason: string = '') {
+  return request<NodeInfo>(`/nodes/${encodeURIComponent(nodeId)}/toggle`, {
+    method: 'PUT',
+    body: JSON.stringify({ disabled, reason }),
+  });
+}
+
+export interface NodeSnapshot {
+  active_calls: number;
+  max_calls: number;
+  idle_cpu: number;
+  load_avg: number;
+  call_failure_rate: number;
+  score: number;
+  ts: number;
+}
+
+export async function getNodeMetrics(nodeId: string): Promise<{ node_id: string; snapshots: NodeSnapshot[]; count: number }> {
+  return request(`/nodes/${encodeURIComponent(nodeId)}/metrics`);
+}
+
+// --- Trunks ---
+export interface Trunk {
+  id: string;
+  name: string;
+  type: 'ingress' | 'balance' | 'fallback';
+  node_id: string;
+  gateway: string;
+  codecs: string[];
+  context: string;
+  enabled: boolean;
+  description: string;
+  created_at: string;
+  updated_at: string;
+}
+
+export async function getTrunks(typeFilter?: string): Promise<Trunk[]> {
+  const q = typeFilter ? `?type=${typeFilter}` : '';
+  return request<Trunk[]>(`/trunks${q}`);
+}
+
+export async function createTrunk(data: Partial<Trunk>) {
+  return request<Trunk>('/trunks', { method: 'POST', body: JSON.stringify(data) });
+}
+
+export async function updateTrunk(id: string, data: Partial<Trunk>) {
+  return request<Trunk>(`/trunks/${encodeURIComponent(id)}`, { method: 'PUT', body: JSON.stringify(data) });
+}
+
+export async function deleteTrunk(id: string) {
+  return request<void>(`/trunks/${encodeURIComponent(id)}`, { method: 'DELETE' });
+}
+
+// --- Users ---
+export interface UserInfo {
+  id: string;
+  username: string;
+  role: string;
+  created_at: string;
+  updated_at: string;
+}
+
+export async function getUsers(): Promise<UserInfo[]> {
+  return request<UserInfo[]>('/users');
+}
+
+export async function createUser(data: { username: string; password: string; role: string }) {
+  return request('/users', { method: 'POST', body: JSON.stringify(data) });
+}
+
+export async function updateUser(id: string, data: { username?: string; password?: string; role?: string }) {
+  return request(`/users/${encodeURIComponent(id)}`, { method: 'PUT', body: JSON.stringify(data) });
+}
+
+export async function deleteUser(id: string) {
+  return request<void>(`/users/${encodeURIComponent(id)}`, { method: 'DELETE' });
+}
+
+// --- WebSocket ---
+export function connectWebSocket(onMessage: (data: any) => void): WebSocket {
+  const token = getToken();
+  const proto = window.location.protocol === 'https:' ? 'wss' : 'ws';
+  const ws = new WebSocket(`${proto}://${window.location.host}/ws/metrics?token=${token}`);
+
+  ws.onmessage = (event) => {
+    try {
+      const data = JSON.parse(event.data);
+      onMessage(data);
+    } catch (e) {
+      console.error('WS parse error:', e);
+    }
+  };
+
+  ws.onclose = () => {
+    // Переподключение через 5 секунд
+    setTimeout(() => {
+      if (getToken()) connectWebSocket(onMessage);
+    }, 5000);
+  };
+
+  return ws;
+}

web/src/routes/+layout.svelte

@@ -0,0 +1,66 @@
+<script lang="ts">
+  import { browser } from '$app/environment';
+  import { page } from '$app/stores';
+  import '../app.css';
+  import { Toaster } from 'svelte-sonner';
+  import { LogIn, LayoutDashboard, Phone, Cable, Users } from 'lucide-svelte';
+
+  let token: string | null = browser ? localStorage.getItem('token') : null;
+  let user: { username: string; role: string } | null = token
+    ? (() => { try { return JSON.parse(atob(token.split('.')[1])); } catch { return null; } })()
+    : null;
+
+  function logout() {
+    if (browser) {
+      localStorage.removeItem('token');
+      localStorage.removeItem('refreshToken');
+    }
+    token = null;
+    user = null;
+  }
+
+  $: pathname = browser ? window.location.pathname : '';
+  $: isLogin = pathname === '/login';
+</script>
+
+<Toaster position="top-right" />
+
+{#if !isLogin}
+  <div class="flex min-h-screen">
+    <!-- Sidebar -->
+    <aside class="w-64 border-r bg-card flex flex-col">
+      <div class="p-4 border-b">
+        <h1 class="text-lg font-bold text-primary">pulse-lets-go</h1>
+        <p class="text-xs text-muted-foreground">Telephone Balancer</p>
+      </div>
+
+      <nav class="flex-1 p-3 space-y-1">
+        <a href="/" class="flex items-center gap-2 px-3 py-2 rounded-md text-sm {pathname === '/' ? 'bg-primary text-primary-foreground' : 'hover:bg-secondary'}">
+          <LayoutDashboard class="h-4 w-4" /> Дашборд
+        </a>
+        <a href="/nodes" class="flex items-center gap-2 px-3 py-2 rounded-md text-sm {pathname === '/nodes' ? 'bg-primary text-primary-foreground' : 'hover:bg-secondary'}">
+          <Phone class="h-4 w-4" /> Ноды
+        </a>
+        <a href="/trunks" class="flex items-center gap-2 px-3 py-2 rounded-md text-sm {pathname === '/trunks' ? 'bg-primary text-primary-foreground' : 'hover:bg-secondary'}">
+          <Cable class="h-4 w-4" /> Транки
+        </a>
+        <a href="/users" class="flex items-center gap-2 px-3 py-2 rounded-md text-sm {pathname === '/users' ? 'bg-primary text-primary-foreground' : 'hover:bg-secondary'}">
+          <Users class="h-4 w-4" /> Пользователи
+        </a>
+      </nav>
+
+      <div class="p-3 border-t text-sm text-muted-foreground">
+        <span>{user?.username ?? '--'}</span>
+        <span class="mx-1">({user?.role ?? '--'})</span>
+        <button on:click={logout} class="ml-2 text-destructive hover:underline text-xs">Выйти</button>
+      </div>
+    </aside>
+
+    <!-- Main content -->
+    <main class="flex-1 p-6">
+      <slot />
+    </main>
+  </div>
+{:else}
+  <slot />
+{/if}

web/src/routes/+page.svelte

@@ -0,0 +1,188 @@
+<script lang="ts">
+  import { browser } from '$app/environment';
+  import { goto } from '$app/navigation';
+  import { onMount, onDestroy } from 'svelte';
+  import {
+    getNodes, connectWebSocket, isAuthenticated,
+    type NodeInfo
+  } from '$lib/api';
+  import { Activity, Phone, Zap, AlertTriangle, Wifi, Server } from 'lucide-svelte';
+
+  let nodes: NodeInfo[] = [];
+  let ws: WebSocket | null = null;
+  let error: string | null = null;
+
+  if (browser && !isAuthenticated()) {
+    goto('/login');
+  }
+
+  onMount(() => {
+    loadNodes();
+    ws = connectWebSocket((msg) => {
+      if (msg.type === 'nodes_update') {
+        nodes = msg.payload;
+      }
+    });
+  });
+
+  onDestroy(() => {
+    ws?.close();
+  });
+
+  async function loadNodes() {
+    try {
+      nodes = await getNodes();
+    } catch (e: any) {
+      error = e.message;
+    }
+  }
+
+  function scoreColor(score: number): string {
+    if (score >= 70) return 'text-green-600';
+    if (score >= 40) return 'text-yellow-600';
+    if (score >= 0) return 'text-orange-600';
+    return 'text-red-600';
+  }
+
+  function scoreBg(score: number): string {
+    if (score >= 70) return 'bg-green-50 border-green-200';
+    if (score >= 40) return 'bg-yellow-50 border-yellow-200';
+    if (score >= 0) return 'bg-orange-50 border-orange-200';
+    return 'bg-red-50 border-red-200';
+  }
+
+  function nodeStatus(n: NodeInfo): string {
+    if (n.disabled) return 'disabled';
+    if (n.is_stale) return 'stale';
+    if (n.status !== 'ok') return 'degraded';
+    if (n.score < 0) return 'unhealthy';
+    return 'healthy';
+  }
+
+  function statusColor(s: string): string {
+    switch (s) {
+      case 'healthy': return 'bg-green-500';
+      case 'degraded': return 'bg-yellow-500';
+      default: return 'bg-red-500';
+    }
+  }
+
+  $: healthyCount = nodes.filter(n => n.score >= 0 && !n.disabled && !n.is_stale).length;
+  $: totalCalls = nodes.reduce((s, n) => s + n.active_calls, 0);
+  $: avgScore = nodes.length > 0 ? nodes.reduce((s, n) => s + n.score, 0) / nodes.length : 0;
+  $: unhealthyList = nodes.filter(n => n.score < 0 || n.disabled || n.is_stale);
+</script>
+
+{#if error}
+  <div class="p-4 border border-red-200 bg-red-50 text-red-700 rounded-md">
+    {error}
+  </div>
+{/if}
+
+<!-- Summary Cards -->
+<div class="grid grid-cols-1 sm:grid-cols-2 lg:grid-cols-4 gap-4 mb-6">
+  <div class="border rounded-lg p-4 bg-card">
+    <div class="flex items-center gap-2 text-sm text-muted-foreground mb-2">
+      <Server class="h-4 w-4" /> Всего нод
+    </div>
+    <div class="text-2xl font-bold">{nodes.length}</div>
+  </div>
+
+  <div class="border rounded-lg p-4 bg-card">
+    <div class="flex items-center gap-2 text-sm text-muted-foreground mb-2">
+      <Activity class="h-4 w-4" /> Здоровых
+    </div>
+    <div class="text-2xl font-bold text-green-600">{healthyCount}</div>
+  </div>
+
+  <div class="border rounded-lg p-4 bg-card">
+    <div class="flex items-center gap-2 text-sm text-muted-foreground mb-2">
+      <Phone class="h-4 w-4" /> Активных звонков
+    </div>
+    <div class="text-2xl font-bold">{totalCalls}</div>
+  </div>
+
+  <div class="border rounded-lg p-4 bg-card">
+    <div class="flex items-center gap-2 text-sm text-muted-foreground mb-2">
+      <Zap class="h-4 w-4" /> Средний score
+    </div>
+    <div class="text-2xl font-bold {scoreColor(avgScore)}">{avgScore.toFixed(1)}</div>
+  </div>
+</div>
+
+<!-- Unhealthy Alerts -->
+{#if unhealthyList.length > 0}
+  <div class="mb-6">
+    <h2 class="flex items-center gap-2 text-sm font-semibold text-destructive mb-2">
+      <AlertTriangle class="h-4 w-4" /> Проблемные ноды ({unhealthyList.length})
+    </h2>
+    <div class="space-y-1">
+      {#each unhealthyList as n}
+        <div class="text-sm text-muted-foreground flex items-center gap-2">
+          <span class="w-2 h-2 rounded-full {statusColor(nodeStatus(n))}"></span>
+          <span class="font-mono">{n.node_id}</span>
+          <span class="text-destructive">score={n.score.toFixed(0)}</span>
+          {#if n.lethal_reason}
+            <span class="text-red-500">— {n.lethal_reason}</span>
+          {/if}
+          {#if n.disabled}
+            <span class="text-orange-500">— disabled: {n.disabled_reason}</span>
+          {/if}
+        </div>
+      {/each}
+    </div>
+  </div>
+{/if}
+
+<!-- Node Cards -->
+<div class="grid grid-cols-1 md:grid-cols-2 lg:grid-cols-3 gap-4">
+  {#each nodes as n (n.node_id)}
+    <div class="border rounded-lg p-4 {scoreBg(n.score)}">
+      <div class="flex items-center justify-between mb-3">
+        <div class="flex items-center gap-2">
+          <span class="w-2 h-2 rounded-full {statusColor(nodeStatus(n))}"></span>
+          <span class="font-semibold">{n.node_id}</span>
+        </div>
+        <span class="text-lg font-bold {scoreColor(n.score)}">
+          {n.score.toFixed(0)}
+        </span>
+      </div>
+
+      <div class="grid grid-cols-2 gap-2 text-xs">
+        <div>
+          <span class="text-muted-foreground">Звонки:</span>
+          <span class="font-mono ml-1">{n.active_calls}/{n.max_calls}</span>
+        </div>
+        <div>
+          <span class="text-muted-foreground">CPU idle:</span>
+          <span class="font-mono ml-1">{n.idle_cpu.toFixed(0)}%</span>
+        </div>
+        <div>
+          <span class="text-muted-foreground">Load:</span>
+          <span class="font-mono ml-1">{n.load_avg.toFixed(2)}</span>
+        </div>
+        <div>
+          <span class="text-muted-foreground">Fail:</span>
+          <span class="font-mono ml-1">{n.call_failure_rate.toFixed(1)}%</span>
+        </div>
+        <div class="col-span-2">
+          <span class="text-muted-foreground">Status:</span>
+          <span class="ml-1">{nodeStatus(n)}</span>
+          <span class="text-muted-foreground ml-2">
+            {n.seconds_ago.toFixed(0)}с назад
+          </span>
+          {#if n.is_stale}
+            <span class="text-red-500 ml-1">STALE</span>
+          {/if}
+        </div>
+      </div>
+    </div>
+  {/each}
+
+  {#if nodes.length === 0}
+    <div class="col-span-full text-center py-12 text-muted-foreground">
+      <Wifi class="h-12 w-12 mx-auto mb-4 opacity-20" />
+      <p>Нет зарегистрированных нод. Ожидание метрик через NATS...</p>
+    </div>
+  {/if}
+</div>

web/src/routes/login/+page.svelte

@@ -0,0 +1,80 @@
+<script lang="ts">
+  import { login, isAuthenticated } from '$lib/api';
+  import { goto } from '$app/navigation';
+  import { browser } from '$app/environment';
+  import { toast } from 'svelte-sonner';
+
+  let username = '';
+  let password = '';
+  let loading = false;
+
+  if (browser && isAuthenticated()) {
+    goto('/');
+  }
+
+  async function handleLogin(e: Event) {
+    e.preventDefault();
+    if (!username || !password) {
+      toast.error('Заполните имя и пароль');
+      return;
+    }
+    loading = true;
+    try {
+      await login(username, password);
+      toast.success('Вход выполнен');
+      goto('/');
+    } catch (err: any) {
+      toast.error(err.message || 'Ошибка входа');
+    } finally {
+      loading = false;
+    }
+  }
+</script>
+
+<div class="min-h-screen flex items-center justify-center bg-secondary">
+  <div class="w-full max-w-sm p-8 bg-card rounded-lg border shadow-sm">
+    <div class="text-center mb-6">
+      <span class="text-4xl">📞</span>
+      <h1 class="text-xl font-bold mt-2">pulse-lets-go</h1>
+      <p class="text-sm text-muted-foreground">Telephone Balancer</p>
+    </div>
+
+    <form on:submit={handleLogin} class="space-y-4">
+      <div>
+        <label for="username" class="block text-sm font-medium mb-1">Имя пользователя</label>
+        <input
+          id="username"
+          type="text"
+          bind:value={username}
+          class="w-full px-3 py-2 border rounded-md text-sm bg-background focus:outline-none focus:ring-2 focus:ring-ring"
+          placeholder="admin"
+          required
+        />
+      </div>
+
+      <div>
+        <label for="password" class="block text-sm font-medium mb-1">Пароль</label>
+        <input
+          id="password"
+          type="password"
+          bind:value={password}
+          class="w-full px-3 py-2 border rounded-md text-sm bg-background focus:outline-none focus:ring-2 focus:ring-ring"
+          placeholder="••••••"
+          required
+        />
+      </div>
+
+      <button
+        type="submit"
+        disabled={loading}
+        class="w-full py-2 px-4 bg-primary text-primary-foreground rounded-md text-sm font-medium hover:opacity-90 disabled:opacity-50"
+      >
+        {loading ? 'Вход...' : 'Войти'}
+      </button>
+    </form>
+
+    <p class="mt-4 text-xs text-muted-foreground text-center">
+      По умолчанию: admin / admin
+    </p>
+  </div>
+</div>

web/src/routes/nodes/+page.svelte

@@ -0,0 +1,166 @@
+<script lang="ts">
+  import { browser } from '$app/environment';
+  import { goto } from '$app/navigation';
+  import { onMount, onDestroy } from 'svelte';
+  import { isAuthenticated, getNodes, toggleNode, connectWebSocket, type NodeInfo } from '$lib/api';
+  import { toast } from 'svelte-sonner';
+  import { Phone, Power, PowerOff } from 'lucide-svelte';
+
+  let nodes: NodeInfo[] = [];
+  let ws: WebSocket | null = null;
+  let loading = true;
+
+  // Toggle dialog
+  let toggleTarget: string | null = null;
+  let toggleDisabling = false;
+  let toggleReason = '';
+
+  if (browser && !isAuthenticated()) { goto('/login'); }
+
+  onMount(() => {
+    loadNodes();
+    ws = connectWebSocket((msg) => {
+      if (msg.type === 'nodes_update') {
+        nodes = msg.payload;
+      }
+    });
+  });
+
+  onDestroy(() => {
+    ws?.close();
+  });
+
+  async function loadNodes() {
+    try {
+      nodes = await getNodes();
+    } catch (e: any) {
+      toast.error(e.message);
+    } finally {
+      loading = false;
+    }
+  }
+
+  function openToggle(nodeId: string, currentlyDisabled: boolean) {
+    toggleTarget = nodeId;
+    toggleDisabling = !currentlyDisabled;
+    toggleReason = '';
+  }
+
+  async function confirmToggle() {
+    if (!toggleTarget) return;
+    try {
+      const updated = await toggleNode(toggleTarget, toggleDisabling, toggleReason);
+      const idx = nodes.findIndex(n => n.node_id === toggleTarget);
+      if (idx >= 0) nodes[idx] = updated;
+      toast.success(toggleDisabling ? `Нода ${toggleTarget} исключена из распределения` : `Нода ${toggleTarget} возвращена в распределение`);
+      toggleTarget = null;
+    } catch (e: any) {
+      toast.error(e.message);
+    }
+  }
+
+  function scoreColor(score: number): string {
+    if (score >= 70) return 'text-green-600';
+    if (score >= 40) return 'text-yellow-600';
+    if (score >= 0) return 'text-orange-600';
+    return 'text-red-600';
+  }
+</script>
+
+<div class="space-y-6">
+  <h1 class="text-xl font-bold flex items-center gap-2">
+    <Phone class="h-5 w-5" /> Ноды
+  </h1>
+
+  {#if loading}
+    <p class="text-muted-foreground text-sm">Загрузка...</p>
+  {:else if nodes.length === 0}
+    <p class="text-muted-foreground text-sm py-8 text-center">Нет зарегистрированных нод.</p>
+  {:else}
+    <div class="border rounded-lg overflow-hidden">
+      <table class="w-full text-sm">
+        <thead class="bg-secondary">
+          <tr>
+            <th class="px-4 py-3 text-left font-medium">Node ID</th>
+            <th class="px-4 py-3 text-left font-medium">Score</th>
+            <th class="px-4 py-3 text-left font-medium">Звонки</th>
+            <th class="px-4 py-3 text-left font-medium">CPU idle</th>
+            <th class="px-4 py-3 text-left font-medium">Load</th>
+            <th class="px-4 py-3 text-left font-medium">Fail %</th>
+            <th class="px-4 py-3 text-left font-medium">Статус</th>
+            <th class="px-4 py-3 text-right font-medium">Управление</th>
+          </tr>
+        </thead>
+        <tbody>
+          {#each nodes as n (n.node_id)}
+            <tr class="border-t hover:bg-secondary/50">
+              <td class="px-4 py-3 font-mono font-medium">{n.node_id}</td>
+              <td class="px-4 py-3 font-mono font-bold {scoreColor(n.score)}">{n.score.toFixed(0)}</td>
+              <td class="px-4 py-3 font-mono">{n.active_calls}/{n.max_calls}</td>
+              <td class="px-4 py-3 font-mono">{n.idle_cpu.toFixed(0)}%</td>
+              <td class="px-4 py-3 font-mono">{n.load_avg.toFixed(2)}</td>
+              <td class="px-4 py-3 font-mono">{n.call_failure_rate.toFixed(1)}%</td>
+              <td class="px-4 py-3">
+                {#if n.disabled}
+                  <span class="text-red-600 font-medium">disabled</span>
+                {:else if n.is_stale}
+                  <span class="text-red-600 font-medium">stale</span>
+                {:else if n.score < 0}
+                  <span class="text-red-600 font-medium">{n.lethal_reason || 'unhealthy'}</span>
+                {:else}
+                  <span class="text-green-600 font-medium">healthy</span>
+                {/if}
+                <div class="text-xs text-muted-foreground">{n.seconds_ago.toFixed(0)}с назад</div>
+              </td>
+              <td class="px-4 py-3 text-right">
+                {#if n.disabled}
+                  <button on:click={() => openToggle(n.node_id, true)} class="flex items-center gap-1 px-3 py-1.5 bg-green-600 text-white rounded text-xs hover:opacity-90">
+                    <Power class="h-3 w-3" /> Вернуть
+                  </button>
+                {:else}
+                  <button on:click={() => openToggle(n.node_id, false)} class="flex items-center gap-1 px-3 py-1.5 bg-red-600 text-white rounded text-xs hover:opacity-90">
+                    <PowerOff class="h-3 w-3" /> Исключить
+                  </button>
+                {/if}
+              </td>
+            </tr>
+          {/each}
+        </tbody>
+      </table>
+    </div>
+  {/if}
+
+  <!-- Toggle confirmation dialog -->
+  {#if toggleTarget}
+    <div class="fixed inset-0 bg-black/50 flex items-center justify-center z-50" on:click={() => (toggleTarget = null)} on:keydown={(e) => { if (e.key === 'Escape') toggleTarget = null; }} role="dialog">
+      <div class="bg-card border rounded-lg p-6 w-full max-w-md shadow-lg" on:click|stopPropagation>
+        <h3 class="text-lg font-semibold mb-2">
+          {toggleDisabling ? 'Исключить ноду из распределения?' : 'Вернуть ноду в распределение?'}
+        </h3>
+        <p class="text-sm text-muted-foreground mb-4">
+          Нода: <span class="font-mono font-medium">{toggleTarget}</span>
+        </p>
+
+        {#if toggleDisabling}
+          <div class="mb-4">
+            <label for="reason" class="block text-sm font-medium mb-1">Причина исключения</label>
+            <input
+              id="reason"
+              type="text"
+              bind:value={toggleReason}
+              class="w-full px-3 py-2 border rounded-md text-sm bg-background"
+              placeholder="Например: технические работы"
+            />
+          </div>
+        {/if}
+
+        <div class="flex gap-2 justify-end">
+          <button on:click={() => (toggleTarget = null)} class="px-4 py-2 border rounded-md text-sm">Отмена</button>
+          <button on:click={confirmToggle} class="px-4 py-2 {toggleDisabling ? 'bg-destructive text-destructive-foreground' : 'bg-primary text-primary-foreground'} rounded-md text-sm font-medium">
+            {toggleDisabling ? 'Исключить' : 'Вернуть'}
+          </button>
+        </div>
+      </div>
+    </div>
+  {/if}
+</div>

web/src/routes/trunks/+page.svelte

@@ -0,0 +1,225 @@
+<script lang="ts">
+  import { browser } from '$app/environment';
+  import { goto } from '$app/navigation';
+  import { onMount } from 'svelte';
+  import { isAuthenticated, getTrunks, createTrunk, updateTrunk, deleteTrunk, type Trunk } from '$lib/api';
+  import { toast } from 'svelte-sonner';
+  import { Plus, Trash2, Save, X, Cable } from 'lucide-svelte';
+
+  let trunks: Trunk[] = [];
+  let loading = true;
+
+  // Edit mode
+  let editing: string | null = null; // trunk ID being edited
+  let editData: Partial<Trunk> = {};
+  let creating = false;
+  let newData: Partial<Trunk> = {
+    type: 'balance',
+    enabled: true,
+    codecs: ['PCMU', 'PCMA'],
+    context: 'default',
+  };
+
+  let typeFilter = '';
+
+  if (browser && !isAuthenticated()) { goto('/login'); }
+
+  onMount(loadTrunks);
+
+  async function loadTrunks() {
+    loading = true;
+    try {
+      trunks = await getTrunks(typeFilter || undefined);
+    } catch (e: any) {
+      toast.error(e.message);
+    } finally {
+      loading = false;
+    }
+  }
+
+  function startEdit(t: Trunk) {
+    editing = t.id;
+    editData = { ...t };
+  }
+
+  function cancelEdit() {
+    editing = null;
+    creating = false;
+    editData = {};
+  }
+
+  async function saveEdit() {
+    if (!editing) return;
+    try {
+      const updated = await updateTrunk(editing, editData);
+      const idx = trunks.findIndex(t => t.id === editing);
+      if (idx >= 0) trunks[idx] = updated;
+      editing = null;
+      toast.success('Транк обновлён');
+    } catch (e: any) {
+      toast.error(e.message);
+    }
+  }
+
+  async function saveCreate() {
+    try {
+      const created = await createTrunk(newData);
+      trunks = [...trunks, created];
+      creating = false;
+      newData = { type: 'balance', enabled: true, codecs: ['PCMU', 'PCMA'], context: 'default' };
+      toast.success('Транк создан');
+    } catch (e: any) {
+      toast.error(e.message);
+    }
+  }
+
+  async function removeTrunk(id: string) {
+    if (!confirm('Удалить транк?')) return;
+    try {
+      await deleteTrunk(id);
+      trunks = trunks.filter(t => t.id !== id);
+      toast.success('Транк удалён');
+    } catch (e: any) {
+      toast.error(e.message);
+    }
+  }
+
+  function typeBadge(type: string): string {
+    switch (type) {
+      case 'ingress': return 'bg-blue-100 text-blue-700';
+      case 'balance': return 'bg-green-100 text-green-700';
+      case 'fallback': return 'bg-orange-100 text-orange-700';
+      default: return 'bg-gray-100 text-gray-700';
+    }
+  }
+
+  function typeLabel(type: string): string {
+    switch (type) {
+      case 'ingress': return 'Вход';
+      case 'balance': return 'Баланс';
+      case 'fallback': return 'Резерв';
+      default: return type;
+    }
+  }
+
+  function onFilterChange(e: Event) {
+    typeFilter = (e.target as HTMLSelectElement).value;
+    loadTrunks();
+  }
+</script>
+
+<div class="space-y-6">
+  <div class="flex items-center justify-between">
+    <h1 class="text-xl font-bold flex items-center gap-2">
+      <Cable class="h-5 w-5" /> Транки
+    </h1>
+    <button on:click={() => (creating = true)} class="flex items-center gap-2 px-4 py-2 bg-primary text-primary-foreground rounded-md text-sm font-medium hover:opacity-90">
+      <Plus class="h-4 w-4" /> Создать
+    </button>
+  </div>
+
+  <!-- Filter -->
+  <div class="flex items-center gap-4">
+    <select value={typeFilter} on:change={onFilterChange} class="px-3 py-2 border rounded-md text-sm bg-background">
+      <option value="">Все типы</option>
+      <option value="ingress">Ingress (входные)</option>
+      <option value="balance">Balance (балансировка)</option>
+      <option value="fallback">Fallback (резерв)</option>
+    </select>
+  </div>
+
+  <!-- Create form -->
+  {#if creating}
+    <div class="border rounded-lg p-4 bg-yellow-50 border-yellow-200">
+      <h3 class="text-sm font-semibold mb-3">Новый транк</h3>
+      <div class="grid grid-cols-1 sm:grid-cols-3 gap-3 mb-3">
+        <input class="px-3 py-2 border rounded-md text-sm" placeholder="Название" bind:value={newData.name} />
+        <select class="px-3 py-2 border rounded-md text-sm bg-background" bind:value={newData.type}>
+          <option value="ingress">Ingress</option>
+          <option value="balance">Balance</option>
+          <option value="fallback">Fallback</option>
+        </select>
+        <input class="px-3 py-2 border rounded-md text-sm" placeholder="Gateway (sip:...)" bind:value={newData.gateway} />
+      </div>
+      <div class="grid grid-cols-1 sm:grid-cols-2 gap-3 mb-3">
+        <input class="px-3 py-2 border rounded-md text-sm" placeholder="Node ID (для balance)" bind:value={newData.node_id} />
+        <input class="px-3 py-2 border rounded-md text-sm" placeholder="Context" bind:value={newData.context} />
+      </div>
+      <div class="flex items-center gap-3 mb-3">
+        <label class="flex items-center gap-2 text-sm">
+          <input type="checkbox" bind:checked={newData.enabled} class="rounded" /> Включён
+        </label>
+        <input class="flex-1 px-3 py-2 border rounded-md text-sm" placeholder="Описание" bind:value={newData.description} />
+      </div>
+      <div class="flex gap-2">
+        <button on:click={saveCreate} class="flex items-center gap-1 px-3 py-2 bg-primary text-primary-foreground rounded-md text-sm"><Save class="h-3 w-3" /> Создать</button>
+        <button on:click={cancelEdit} class="flex items-center gap-1 px-3 py-2 border rounded-md text-sm"><X class="h-3 w-3" /> Отмена</button>
+      </div>
+    </div>
+  {/if}
+
+  {#if loading}
+    <p class="text-muted-foreground text-sm">Загрузка...</p>
+  {:else if trunks.length === 0}
+    <p class="text-muted-foreground text-sm py-8 text-center">Нет транков. Создайте первый.</p>
+  {:else}
+    <div class="border rounded-lg overflow-hidden">
+      <table class="w-full text-sm">
+        <thead class="bg-secondary">
+          <tr>
+            <th class="px-4 py-3 text-left font-medium">Название</th>
+            <th class="px-4 py-3 text-left font-medium">Тип</th>
+            <th class="px-4 py-3 text-left font-medium">Gateway</th>
+            <th class="px-4 py-3 text-left font-medium">Node ID</th>
+            <th class="px-4 py-3 text-left font-medium">Статус</th>
+            <th class="px-4 py-3 text-right font-medium">Действия</th>
+          </tr>
+        </thead>
+        <tbody>
+          {#each trunks as t (t.id)}
+            {#if editing === t.id}
+              <!-- Edit row -->
+              <tr class="border-t bg-yellow-50">
+                <td class="px-4 py-2"><input class="w-full px-2 py-1 border rounded text-sm" bind:value={editData.name} /></td>
+                <td class="px-4 py-2">
+                  <select class="w-full px-2 py-1 border rounded text-sm" bind:value={editData.type}>
+                    <option value="ingress">Ingress</option>
+                    <option value="balance">Balance</option>
+                    <option value="fallback">Fallback</option>
+                  </select>
+                </td>
+                <td class="px-4 py-2"><input class="w-full px-2 py-1 border rounded text-sm" bind:value={editData.gateway} /></td>
+                <td class="px-4 py-2"><input class="w-full px-2 py-1 border rounded text-sm" bind:value={editData.node_id} /></td>
+                <td class="px-4 py-2">
+                  <label class="flex items-center gap-2 text-sm">
+                    <input type="checkbox" bind:checked={editData.enabled} />
+                    {editData.enabled ? 'Вкл' : 'Выкл'}
+                  </label>
+                </td>
+                <td class="px-4 py-2 text-right">
+                  <div class="flex gap-1 justify-end">
+                    <button on:click={saveEdit} class="px-2 py-1 bg-primary text-primary-foreground rounded text-xs"><Save class="h-3 w-3 inline" /></button>
+                    <button on:click={cancelEdit} class="px-2 py-1 border rounded text-xs"><X class="h-3 w-3 inline" /></button>
+                  </div>
+                </td>
+              </tr>
+            {:else}
+              <!-- Normal row -->
+              <tr class="border-t hover:bg-secondary/50">
+                <td class="px-4 py-3 font-medium">{t.name}</td>
+                <td class="px-4 py-3"><span class="px-2 py-1 rounded text-xs font-medium {typeBadge(t.type)}">{typeLabel(t.type)}</span></td>
+                <td class="px-4 py-3 font-mono text-xs">{t.gateway}</td>
+                <td class="px-4 py-3 font-mono text-xs">{t.node_id || '—'}</td>
+                <td class="px-4 py-3">{t.enabled ? '🟢 Вкл' : '🔴 Выкл'}</td>
+                <td class="px-4 py-3 text-right">
+                  <button on:click={() => startEdit(t)} class="px-2 py-1 text-xs text-primary hover:underline mr-1">Изменить</button>
+                  <button on:click={() => removeTrunk(t.id)} class="px-2 py-1 text-xs text-destructive hover:underline"><Trash2 class="h-3 w-3 inline" /></button>
+                </td>
+              </tr>
+            {/if}
+          {/each}
+        </tbody>
+      </table>
+    </div>
+  {/if}
+</div>

web/src/routes/users/+page.svelte

@@ -0,0 +1,375 @@
+<script lang="ts">
+  import { browser } from '$app/environment';
+  import { goto } from '$app/navigation';
+  import { onMount } from 'svelte';
+  import { isAuthenticated, getUsers, createUser, updateUser, deleteUser, type UserInfo } from '$lib/api';
+  import { toast } from 'svelte-sonner';
+  import { Users, Plus, Save, X, Trash2 } from 'lucide-svelte';
+
+  let users: UserInfo[] = [];
+  let loading = true;
+
+  // Создание
+  let creating = false;
+  let newUsername = '';
+  let newPassword = '';
+  let newRole = 'viewer';
+
+  // Редактирование
+  let editing: string | null = null;
+  let editUsername = '';
+  let editPassword = '';
+  let editRole = 'viewer';
+
+  // Подтверждение удаления
+  let deleteTarget: string | null = null;
+  let deleteUsername = '';
+  let deleteIsLastAdmin = false;
+
+  if (browser && !isAuthenticated()) {
+    goto('/login');
+  }
+
+  onMount(() => {
+    loadUsers();
+  });
+
+  async function loadUsers() {
+    loading = true;
+    try {
+      users = await getUsers();
+    } catch (e: any) {
+      toast.error(e.message || 'Ошибка загрузки');
+    } finally {
+      loading = false;
+    }
+  }
+
+  // ── Создание ────────────────────────────────────────────────────
+
+  async function handleCreate() {
+    if (!newUsername || !newPassword) {
+      toast.error('Заполните имя и пароль');
+      return;
+    }
+    try {
+      const u = await createUser({ username: newUsername, password: newPassword, role: newRole });
+      users = [...users, u];
+      creating = false;
+      newUsername = ''; newPassword = ''; newRole = 'viewer';
+      toast.success('Пользователь создан');
+    } catch (e: any) {
+      toast.error(e.message || 'Ошибка создания');
+    }
+  }
+
+  function cancelCreate() {
+    creating = false;
+    newUsername = ''; newPassword = ''; newRole = 'viewer';
+  }
+
+  // ── Редактирование ──────────────────────────────────────────────
+
+  function startEdit(u: UserInfo) {
+    editing = u.id;
+    editUsername = u.username;
+    editPassword = '';
+    editRole = u.role;
+  }
+
+  function cancelEdit() {
+    editing = null;
+  }
+
+  async function saveEdit() {
+    if (!editing || !editUsername) return;
+    const data: { username?: string; password?: string; role?: string } = {
+      username: editUsername,
+      role: editRole,
+    };
+    if (editPassword) {
+      data.password = editPassword;
+    }
+    try {
+      const updated = await updateUser(editing, data);
+      const idx = users.findIndex(u => u.id === editing);
+      if (idx >= 0) {
+        users = [...users.slice(0, idx), updated, ...users.slice(idx + 1)];
+      }
+      editing = null;
+      toast.success('Пользователь обновлён');
+    } catch (e: any) {
+      toast.error(e.message || 'Ошибка обновления');
+    }
+  }
+
+  // ── Удаление ────────────────────────────────────────────────────
+
+  function confirmDelete(u: UserInfo) {
+    const adminCount = users.filter(x => x.role === 'admin').length;
+    deleteIsLastAdmin = u.role === 'admin' && adminCount <= 1;
+    deleteTarget = u.id;
+    deleteUsername = u.username;
+  }
+
+  function cancelDelete() {
+    deleteTarget = null;
+  }
+
+  async function executeDelete() {
+    if (!deleteTarget || deleteIsLastAdmin) return;
+    try {
+      await deleteUser(deleteTarget);
+      users = users.filter(u => u.id !== deleteTarget);
+      deleteTarget = null;
+      toast.success('Пользователь удалён');
+    } catch (e: any) {
+      toast.error(e.message || 'Ошибка удаления');
+    }
+  }
+
+  // ── Форматирование ──────────────────────────────────────────────
+
+  function roleBadge(role: string): string {
+    return role === 'admin'
+      ? 'bg-purple-100 text-purple-700'
+      : 'bg-gray-100 text-gray-700';
+  }
+
+  function formatDate(d: string): string {
+    if (!d) return '—';
+    return new Date(d).toLocaleDateString('ru-RU', {
+      year: 'numeric', month: '2-digit', day: '2-digit',
+      hour: '2-digit', minute: '2-digit',
+    });
+  }
+
+  // Проверка: является ли текущий пользователь владельцем строки
+  function currentUsername(): string {
+    const token = browser ? localStorage.getItem('token') : null;
+    if (!token) return '';
+    try {
+      const payload = JSON.parse(atob(token.split('.')[1]));
+      return payload?.username || '';
+    } catch { return ''; }
+  }
+</script>
+
+<div class="space-y-6">
+  <!-- Заголовок -->
+  <div class="flex items-center justify-between">
+    <h1 class="text-xl font-bold flex items-center gap-2">
+      <Users class="h-5 w-5" /> Пользователи
+    </h1>
+    <button
+      on:click={() => (creating = true)}
+      class="flex items-center gap-2 px-4 py-2 bg-primary text-primary-foreground rounded-md text-sm font-medium hover:opacity-90"
+    >
+      <Plus class="h-4 w-4" /> Создать
+    </button>
+  </div>
+
+  <!-- ── Форма создания ────────────────────────────────────────── -->
+
+  {#if creating}
+    <div class="border rounded-lg p-4 bg-yellow-50 border-yellow-200">
+      <h3 class="text-sm font-semibold mb-3">Новый пользователь</h3>
+      <div class="grid grid-cols-1 sm:grid-cols-3 gap-3 mb-3">
+        <input
+          class="px-3 py-2 border rounded-md text-sm bg-background"
+          placeholder="Имя пользователя"
+          bind:value={newUsername}
+        />
+        <input
+          class="px-3 py-2 border rounded-md text-sm bg-background"
+          type="password"
+          placeholder="Пароль"
+          bind:value={newPassword}
+        />
+        <select
+          class="px-3 py-2 border rounded-md text-sm bg-background"
+          bind:value={newRole}
+        >
+          <option value="admin">admin</option>
+          <option value="viewer">viewer</option>
+        </select>
+      </div>
+      <div class="flex gap-2">
+        <button
+          on:click={handleCreate}
+          class="flex items-center gap-1 px-3 py-2 bg-primary text-primary-foreground rounded-md text-sm"
+        >
+          <Save class="h-3 w-3" /> Создать
+        </button>
+        <button
+          on:click={cancelCreate}
+          class="flex items-center gap-1 px-3 py-2 border rounded-md text-sm"
+        >
+          <X class="h-3 w-3" /> Отмена
+        </button>
+      </div>
+    </div>
+  {/if}
+
+  <!-- ── Таблица ────────────────────────────────────────────────── -->
+
+  {#if loading}
+    <p class="text-muted-foreground text-sm">Загрузка...</p>
+  {:else if users.length === 0}
+    <p class="text-muted-foreground text-sm py-8 text-center">
+      Нет пользователей. Создайте первого.
+    </p>
+  {:else}
+    <div class="border rounded-lg overflow-hidden">
+      <table class="w-full text-sm">
+        <thead class="bg-secondary">
+          <tr>
+            <th class="px-4 py-3 text-left font-medium">Имя пользователя</th>
+            <th class="px-4 py-3 text-left font-medium">Роль</th>
+            <th class="px-4 py-3 text-left font-medium">Создан</th>
+            <th class="px-4 py-3 text-right font-medium">Действия</th>
+          </tr>
+        </thead>
+        <tbody>
+          {#each users as u (u.id)}
+            {#if editing === u.id}
+              <!-- ── Строка редактирования ── -->
+              <tr class="border-t bg-yellow-50">
+                <td class="px-4 py-2">
+                  <input
+                    class="w-full px-2 py-1 border rounded text-sm bg-background"
+                    bind:value={editUsername}
+                  />
+                </td>
+                <td class="px-4 py-2">
+                  {#if u.id === 'user-01'}
+                    <span class="px-2 py-1 rounded text-xs font-medium bg-purple-100 text-purple-700">
+                      admin 🔒
+                    </span>
+                    <span class="text-xs text-muted-foreground ml-1">защищён</span>
+                  {:else}
+                    <select
+                      class="w-full px-2 py-1 border rounded text-sm bg-background"
+                      bind:value={editRole}
+                    >
+                      <option value="admin">admin</option>
+                      <option value="viewer">viewer</option>
+                    </select>
+                  {/if}
+                </td>
+                <td class="px-4 py-2 text-muted-foreground text-xs">
+                  {formatDate(u.created_at)}
+                </td>
+                <td class="px-4 py-2 text-right">
+                  <div class="flex gap-1 justify-end">
+                    <input
+                      class="w-24 px-2 py-1 border rounded text-xs bg-background"
+                      type="password"
+                      placeholder="Новый пароль"
+                      bind:value={editPassword}
+                    />
+                    <button
+                      on:click={saveEdit}
+                      class="px-2 py-1 bg-primary text-primary-foreground rounded text-xs"
+                    >
+                      <Save class="h-3 w-3 inline" />
+                    </button>
+                    <button
+                      on:click={cancelEdit}
+                      class="px-2 py-1 border rounded text-xs"
+                    >
+                      <X class="h-3 w-3 inline" />
+                    </button>
+                  </div>
+                </td>
+              </tr>
+            {:else}
+              <!-- ── Обычная строка ── -->
+              <tr class="border-t hover:bg-secondary/50">
+                <td class="px-4 py-3">
+                  <span class="font-medium">{u.username}</span>
+                  {#if u.id === 'user-01'}
+                    <span class="text-xs text-purple-600 ml-1" title="Первичный администратор. Роль защищена от изменения.">основной</span>
+                  {/if}
+                  {#if u.username === currentUsername()}
+                    <span class="text-xs text-muted-foreground ml-2">(вы)</span>
+                  {/if}
+                </td>
+                <td class="px-4 py-3">
+                  <span class="px-2 py-0.5 rounded text-xs font-medium {roleBadge(u.role)}">
+                    {u.role}
+                  </span>
+                </td>
+                <td class="px-4 py-3 text-xs text-muted-foreground">
+                  {formatDate(u.created_at)}
+                </td>
+                <td class="px-4 py-3 text-right">
+                  <button
+                    on:click={() => startEdit(u)}
+                    class="px-2 py-1 text-xs text-primary hover:underline mr-1"
+                  >
+                    Изменить
+                  </button>
+                  {#if u.id !== 'user-01'}
+                    <button
+                      on:click={() => confirmDelete(u)}
+                      class="px-2 py-1 text-xs text-destructive hover:underline"
+                    >
+                      <Trash2 class="h-3 w-3 inline" />
+                    </button>
+                  {/if}
+                </td>
+              </tr>
+            {/if}
+          {/each}
+        </tbody>
+      </table>
+    </div>
+  {/if}
+
+  <!-- ── Модальное окно удаления ────────────────────────────────── -->
+
+  {#if deleteTarget}
+    <div
+      class="fixed inset-0 bg-black/50 flex items-center justify-center z-50"
+      on:click={cancelDelete}
+      on:keydown={(e) => { if (e.key === 'Escape') cancelDelete(); }}
+      role="dialog"
+    >
+      <div class="bg-card border rounded-lg p-6 w-full max-w-md shadow-lg" on:click|stopPropagation>
+        <h3 class="text-lg font-semibold mb-2">
+          {deleteIsLastAdmin ? 'Невозможно удалить' : 'Удалить пользователя?'}
+        </h3>
+
+        {#if deleteIsLastAdmin}
+          <p class="text-sm text-muted-foreground mb-4">
+            <strong>{deleteUsername}</strong> — последний администратор.
+            Сначала назначьте другого пользователя администратором.
+          </p>
+          <div class="flex justify-end">
+            <button on:click={cancelDelete} class="px-4 py-2 border rounded-md text-sm">
+              Понятно
+            </button>
+          </div>
+        {:else}
+          <p class="text-sm text-muted-foreground mb-4">
+            Вы уверены, что хотите удалить пользователя
+            <strong>{deleteUsername}</strong>?
+            Это действие нельзя отменить.
+          </p>
+          <div class="flex gap-2 justify-end">
+            <button on:click={cancelDelete} class="px-4 py-2 border rounded-md text-sm">
+              Отмена
+            </button>
+            <button
+              on:click={executeDelete}
+              class="px-4 py-2 bg-destructive text-destructive-foreground rounded-md text-sm font-medium hover:opacity-90"
+            >
+              Удалить
+            </button>
+          </div>
+        {/if}
+      </div>
+    </div>
+  {/if}
+</div>

web/svelte.config.js

@@ -0,0 +1,22 @@
+import adapter from '@sveltejs/adapter-static';
+import { vitePreprocess } from '@sveltejs/vite-plugin-svelte';
+
+/** @type {import('@sveltejs/kit').Config} */
+const config = {
+  preprocess: vitePreprocess(),
+
+  kit: {
+    adapter: adapter({
+      pages: 'build',
+      assets: 'build',
+      fallback: 'index.html',
+      precompress: false,
+      strict: false
+    }),
+    alias: {
+      '$lib': './src/lib'
+    }
+  }
+};
+
+export default config;

web/vite.config.ts

@@ -0,0 +1,17 @@
+import tailwindcss from '@tailwindcss/vite';
+import { sveltekit } from '@sveltejs/kit/vite';
+import { defineConfig } from 'vite';
+
+export default defineConfig({
+  plugins: [tailwindcss(), sveltekit()],
+
+  server: {
+    proxy: {
+      '/api': 'http://localhost:8080',
+      '/ws': {
+        target: 'ws://localhost:8080',
+        ws: true
+      }
+    }
+  }
+});