chore(release): 2.0.0-beta.13 (#55)

Co-authored-by: by-sonic <171230345+by-sonic@users.noreply.github.com>

.github/workflows/release.yml

@@ -9,7 +9,40 @@ permissions:
   contents: write
 
 jobs:
+  # Токен Actions умеет создавать релиз только на HEAD ветки по умолчанию. Если
+  # тег отстал хоть на один коммит, GitHub отвечает «Resource not accessible by
+  # integration» — сообщение про права, хотя права в порядке и дело в положении
+  # тега. Так утонул v2.0.0-beta.8: тег поставили, следом дописали коммит в main,
+  # и три сборки по восемь минут закончились загадочным 403.
+  #
+  # Проверка занимает секунды и идёт до сборок. Но она НЕ закрывает гонку: если
+  # запушить в main уже после её прохождения, публикация всё равно упадёт — как и
+  # случилось с beta.8. Единственная настоящая защита — порядок действий: тег
+  # ставится последним, и пока идёт релиз, в main не пушим.
+  guard:
+    name: Тег должен стоять на HEAD
+    runs-on: ubuntu-latest
+    steps:
+      - name: Сверить тег с веткой по умолчанию
+        env:
+          GH_TOKEN: ${{ github.token }}
+        run: |
+          branch=$(gh api "repos/$GITHUB_REPOSITORY" -q .default_branch)
+          head=$(gh api "repos/$GITHUB_REPOSITORY/commits/$branch" -q .sha)
+          if [ "$head" = "$GITHUB_SHA" ]; then
+            echo "$GITHUB_REF_NAME и $branch указывают на $head — собираем."
+            exit 0
+          fi
+          echo "::error::$GITHUB_REF_NAME стоит на $GITHUB_SHA, а $branch — на $head. Публикация упадёт с 403, потому что токен Actions создаёт релиз только на HEAD ветки по умолчанию."
+          echo "Переставьте тег и запушьте заново:"
+          echo "  git tag -d $GITHUB_REF_NAME"
+          echo "  git push origin :refs/tags/$GITHUB_REF_NAME"
+          echo "  git tag -a $GITHUB_REF_NAME $head -m 'TGLock ...'"
+          echo "  git push origin $GITHUB_REF_NAME"
+          exit 1
+
   publish:
+    needs: guard
     name: Build ${{ matrix.platform }}
     strategy:
       fail-fast: false
@@ -64,13 +97,20 @@ jobs:
         with:
           tagName: v__VERSION__
           releaseName: TGLock v__VERSION__
+          # Только инструкция по скачиванию: она одна и та же для любой версии.
+          # Список изменений дописывается в release notes при выпуске — иначе
+          # выходит как в бетах 1-7, где каждая несла один и тот же текст «новый
+          # TGLock, полностью обновлённый интерфейс» и понять, что поменялось,
+          # было невозможно.
           releaseBody: |
-            Новый TGLock: адаптивный MTProto/WebSocket-транспорт и полностью обновлённый интерфейс на Tauri 2.
+            ## Что скачивать
 
-            - macOS: скачайте универсальный `.dmg` или `.app.tar.gz`
-            - Windows: скачайте `.exe` установщик
-            - Linux: скачайте `.AppImage` или `.deb`
-            - Сервер или машина без монитора: скачайте `tglock-cli-*` — там нет графического интерфейса
+            - **Windows** — `.exe`, установщик
+            - **macOS** — универсальный `.dmg` (или `.app.tar.gz`)
+            - **Linux** — `.AppImage` или `.deb`
+            - **Сервер, контейнер, машина без монитора** — `tglock-cli-*`: то же самое, но без графического интерфейса
+
+            Если Windows ругается на файл — [почему так и что с этим делать](https://github.com/by-sonic/tglock#-антивирус-ругается-smartscreen-предупреждает-virustotal-показывает-детекты).
           releaseDraft: false
           prerelease: false
           args: ${{ matrix.args }}

Cargo.lock

@@ -3553,7 +3553,7 @@ dependencies = [
 
 [[package]]
 name = "tglock"
-version = "2.0.0-beta.7"
+version = "2.0.0-beta.13"
 dependencies = [
  "aes",
  "cipher",

Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "tglock"
-version = "2.0.0-beta.7"
+version = "2.0.0-beta.13"
 edition = "2021"
 rust-version = "1.88"
 description = "Telegram unblock via local WebSocket tunnel"

README.md

@@ -155,12 +155,23 @@ Telegram → Настройки → **Продвинутые** → Тип сое
 
 В окне TGLock включи галочку **LAN** — приложение начнёт слушать на `0.0.0.0`. Все устройства в домашней сети (телефон, планшет, ноутбук, телевизор) смогут подключиться к `<IP-компьютера>:1080` и тоже получить рабочий Telegram.
 
-Ссылку `tg://proxy` с уже подставленным адресом TGLock открывает сам при включении — её достаточно переслать себе в Telegram и открыть на телефоне. Если нужен адрес руками: `ipconfig` на Windows, `ip a` на Linux, `ifconfig` на macOS.
+Когда LAN-режим включён, TGLock показывает в окне **готовый адрес** вида `192.168.1.7:1080` — нажми на него, чтобы скопировать. Плюс он сам открывает ссылку `tg://proxy`, где уже подставлены адрес, порт и секрет: её достаточно переслать себе в Telegram и открыть на телефоне.
+
+> ⚠️ На другом устройстве **не вводи `127.0.0.1`** — для него это оно само, а не твой компьютер. Нужен именно тот адрес, который показан в окне TGLock. Это же касается телефона в эмуляторе (MuMuPlayer, BlueStacks и подобных): внутри эмулятора Android — отдельная машина со своей сетью.
+
+Если адрес нужен руками: `ipconfig` на Windows, `ip a` на Linux, `ifconfig` на macOS.
 
 Удобно, если дома один компьютер всегда включён — он становится «домашним Telegram-роутером».
 
 В LAN-режиме TGLock пропускает **только адреса Telegram**. Открытым SOCKS5-прокси для всего интернета он при этом не становится — иначе им бы воспользовались не только твои устройства.
 
+> **📵 С телефона не подключается?** Открой **Диагностика** на компьютере и посмотри две цифры.
+>
+> - **Соединения `0` и Отклонено `0`** — телефон до компьютера не дошёл. Дело не в TGLock: проверь, что оба устройства в одной сети (телефон может сидеть на гостевом Wi-Fi или в мобильном интернете), что в роутере не включена изоляция клиентов, и что брандмауэр пускает входящие на порт TGLock.
+> - **Соединения растут, Отклонено растёт** — телефон дошёл, но просит адрес, который LAN-режим не пропускает. Конкретный адрес назван в журнале событий ниже — пришли эту строку в issue.
+> - **Не опознаны растёт** — телефон дошёл, но договориться не вышло. Почти всегда в Telegram на телефоне вписана ссылка от прошлого запуска, то есть другой секрет. Сверь её с той, что показана в окне сейчас.
+> - **Соединения растут, Туннели `0`** — до Telegram не доходит уже сам компьютер. Это [Cloudflare Worker](docs/CLOUDFLARE_WORKER.md), а не проблема LAN.
+
 ### 🖥 Без графического интерфейса: `tglock-cli`
 
 Для сервера, виртуалки, контейнера и машины без монитора или без 3D-ускорения. Это отдельный бинарь, в котором **нет ни Tauri, ни системного WebView** — там, где окно просто не создаётся, CLI работает.
@@ -197,7 +208,7 @@ worker = ["my-name.workers.dev"]
 
 Файл с секретом внутри держите с правами `600`: это доступ к вашему прокси.
 
-При запуске печатается готовая `tg://proxy`-ссылка — её можно открыть на любом устройстве в сети, чтобы Telegram настроился сам. Дальше в лог идёт по строке на каждое изменение состояния: сколько соединений, какой дата-центр, какой маршрут живой, сколько сбоев.
+При запуске печатается готовая `tg://proxy`-ссылка — её можно открыть на любом устройстве в сети, чтобы Telegram настроился сам. Дальше в лог идёт по строке на каждое изменение состояния: сколько соединений, какой дата-центр, какой маршрут живой, сколько сбоев, сколько запросов отклонено политикой «только Telegram» и сколько клиентов не опознано. Отдельными строками отмечаются подключившиеся устройства, адреса, из-за которых был отказ, и клиенты, с которыми не удалось договориться, — по ним видно, дошёл ли телефон до сервиса вообще и не вписан ли в нём устаревший секрет.
 
 Прав администратора не нужно: TGLock не правит ни системный DNS, ни файл `hosts` — нужные адреса Telegram зашиты в маршрутах, а TLS SNI остаётся настоящим.
 

docs/ARCHITECTURE_V2.md

@@ -55,6 +55,125 @@ LAN-режим превращал бы машину в открытый прок
 `config::ListenConfig`, а не в условиях по месту вызова; переопределяется
 только явным `--allow-direct` в CLI.
 
+### Что считается адресом Telegram
+
+Список сетей — опубликованный самим Telegram
+(<https://core.telegram.org/resources/cidr.txt>), он лежит в `telegram_net` и
+проверяется по маске префикса. До 2.0.0-beta.9 сравнивались два первых октета,
+то есть «телеграмом» считались целиком `149.154.0.0/16`, `91.108.0.0/16`,
+`91.105.0.0/16` и `185.76.0.0/16`, а IPv6 не распознавался вовсе. Ошибка была в
+обе стороны:
+
+- чужие адреса внутри этих `/16` уходили в MTProto-туннель и умирали там;
+- настоящие адреса дата-центров по IPv6 отклонялись как посторонние.
+
+Второе и давало «на компьютере работает, с телефона нет» (#42): на loopback
+неопознанный адрес всё равно релеился напрямую, поэтому там дефект не
+проявлялся, а на сетевом слушателе тот же адрес получал отказ.
+
+Назначение делится на три вида:
+
+| Вид | Что это | Что делаем |
+|---|---|---|
+| Дата-центр | IP из опубликованных сетей, v4 или v6 | заворачиваем в WebSocket |
+| Веб Telegram | имя из `telegram.org`, `t.me`, `telegram.me`, `telesco.pe`, `cdn-telegram.org` | пропускаем как есть — это обычный HTTPS, а не MTProto |
+| Всё остальное | — | напрямую на loopback, отказ на сетевом адресе |
+
+Имена сопоставляются по границе метки, поэтому `telegram.org.example.com` —
+посторонний домен. В ограниченном режиме имя разрешается заранее, и адреса
+внутри локальной сети (`127.0.0.0/8`, `10/8`, `172.16/12`, `192.168/16`,
+`100.64/10`, `fc00::/7`, `fe80::/10`) отбрасываются: назначение выбирает чужое
+устройство, и DNS-ответ не должен превращать TGLock в дверь во внутреннюю сеть
+этой машины.
+
+### Отказ перестаёт быть молчаливым
+
+Отклонённый запрос увеличивает счётчик `blocked` и один раз называет адрес в
+журнале; повторы того же адреса склеиваются, чтобы не забить журнал одной
+строкой. Отдельно отмечается первое подключение с каждого сетевого адреса.
+
+Без этого «с телефона не работает» неразличимо распадалось на два случая:
+телефон не дошёл до машины (сеть, брандмауэр, изоляция клиентов на роутере) —
+и дошёл, но попросил адрес, который мы не пропускаем. Первый виден как ноль
+соединений и ноль отказов, второй — как соединения есть, отказы растут.
+
+Третий случай нашёлся, когда репортёр #42 прислал диагностику: у него было ноль
+отказов и работающие туннели, то есть оба счётчика говорили «всё хорошо».
+Клиент, который дошёл до прокси, но не сумел договориться, не попадал ни в
+один из них. Соединение просто закрывалось: `active` дёргался вверх и обратно.
+
+Теперь такие клиенты считает `unknown_clients`, и журнал называет адрес и
+причину. Их две:
+
+- MTProto-init не разбирается под текущим секретом. Почти всегда это ссылка
+  `tg://proxy` от прошлого запуска: секрет — её половина, и клиент со
+  сохранённой старой ссылкой попадает ровно сюда. Со стороны Telegram это и
+  есть «прокси настроен неверно и будет отключён» (#37).
+- SOCKS5-приветствие не разбирается. Сюда же попадает MTProto-соединение,
+  ушедшее в SOCKS5-ветку по неоднозначному первому байту, если полный init не
+  успел прийти за `PROTOCOL_PROBE_TIMEOUT`.
+
+Счётчик `ws_failures` от них отличается тем, что растёт после успешного
+рукопожатия с клиентом: там договорились с клиентом, но не смогли с Telegram.
+
+### Почему не поднялся туннель
+
+`ws_failures` говорит, что каскад маршрутов упал целиком, и молчит о причине.
+Текст с перечислением попыток собирался в `TransportEngine::connect` и там же
+пропадал: наверх уходил `Err`, который выбрасывался в `serve`. При `туннелей 0`
+и растущих сбоях отличить «провайдер режет закреплённые адреса» от «воркер
+отвечает отказом» было нечем — ровно та стена, в которую упёрся репортёр #50.
+
+Теперь причина попадает в журнал одной строкой на каждый набор отказов:
+
+```
+Не поднялся туннель до DC2: 149.154.167.51 — не отвечает (таймаут TCP);
+kws2.web.telegram.org — таймаут TLS/WebSocket; my.workers.dev — рукопожатие
+WebSocket: HTTP error: 403 Forbidden
+```
+
+Дедупликация журнала делает эту строку разовой: маршруты у DC стабильны, и
+повтор той же комбинации отказов не пишется.
+
+Домены Cloudflare Worker отчитываются так же. Строка, не похожая на имя хоста,
+раньше отбрасывалась молча — `https://name.workers.dev/` со схемой или слэшем не
+проходит `valid_domain`, маршрут не появлялся, и «воркер настроен» ничем не
+отличалось от «воркера нет». Теперь отвергнутая строка называется вместе с
+причиной, а принятая подтверждается: `Cloudflare Worker в списке маршрутов:
+name.workers.dev`.
+
+## Туннель: два независимых направления
+
+Каждое клиентское соединение получает свой WebSocket-туннель, и внутри него
+данные идут в обе стороны сразу. До 2.0.0-beta.12 оба направления обслуживал
+один `select!` с пометкой `biased`, и это давало два дефекта, снаружи
+выглядевших одинаково: «Подключено», а ничего не идёт.
+
+`biased` опрашивает ветки строго по порядку. Пока в первой — «Telegram →
+клиент» — есть данные, до второй очередь не доходит вообще. То есть при
+непрерывном потоке вниз (первичная синхронизация телефона, загрузка медиа)
+исходящие пакеты клиента не читались.
+
+Второй дефект — одна задача на оба направления. `tcp_w.write_all` ждёт, пока
+клиент разберёт присланное, и всё это время не опрашивается чтение от клиента.
+Телефон по Wi-Fi разбирает поток медленнее, чем Telegram Desktop на той же
+машине через loopback, — отсюда асимметрия «на компьютере работает, на телефоне
+нет» из #42.
+
+Для MTProto это фатально: клиент обязан слать подтверждения, а за каждым
+следующим куском файла — свой `upload.getFile`. Первый запрос уходит, дальше
+идёт поток вниз, и следующие запросы наверх не попадают. Загрузка встаёт при
+живом туннеле, нулевых сбоях и нулевых отклонениях — ровно картина из #32.
+
+Теперь это две независимые половины: `ws.split()` плюс `CryptoContext::split()`,
+потому что шифры направлений независимы — два потока AES-CTR со своими ключами.
+Ping приходит в читающую половину, а отвечает на него пишущая, через канал на
+четыре слота: владелец отправляющей половины должен оставаться ровно один.
+
+Оба дефекта закрыты тестами, которые падают на beta.11. Первый: за пять секунд
+непрерывной загрузки наверх не уходит ни одного байта. Второй: клиент, не
+успевающий читать, замораживает собственную отправку.
+
 ## Учёт состояния
 
 `Stats::ws` считает **установленные** туннели: счётчик поднимается после
@@ -63,6 +182,14 @@ LAN-режим превращал бы машину в открытый прок
 несколько секунд каждый. Состояния «порт открыт», «идёт перебор маршрутов» и
 «туннель установлен» различимы и в GUI, и в выводе CLI.
 
+Дата-центр и маршрут пишутся **одним значением**, в момент, когда туннель
+поднялся. Пока это были два независимых поля, номер писало соединение при
+разборе init, а маршрут — другое соединение после рукопожатия, и при десятках
+одновременных соединений в строку статуса попадала пара из разных из них.
+Читалась она как «до этого DC шли этим маршрутом», хотя означала другое: в
+диагностике #42 встречались строки `DC5 · Запасной Telegram IP`, а у DC5
+закреплённый адрес всего один и запасного у него не бывает вовсе.
+
 Секрет прокси — половина ссылки `tg://proxy`. Для сервиса его нужно закрепить
 файлом (`--secret-file`): под `DynamicUser` и `ProtectHome` домашней папки нет,
 путь по умолчанию не определяется, и секрет генерировался бы заново при каждом

docs/ISSUE_AUDIT.md

@@ -41,6 +41,44 @@
 > кодом, LAN-режим ограничен адресами Telegram на уровне типа, Cloudflare Worker
 > остаётся исключительно пользовательской настройкой.
 
+> **Статус на 19 августа 2026.** С прошлой отметки вышли beta.6, beta.7,
+> beta.8 и beta.9. Что закрыто и что осталось:
+>
+> - **#32 (медиа).** Файл настроек `tglock.toml` сделан в beta.6 — это была
+>   отдельная просьба из того же issue. Заодно исправлена паника `println!` при
+>   закрытом stdout. Причина проблем с медиа не подтверждена: репортёр не
+>   прислал строку статуса в момент, когда фото не грузится. Слабое место
+>   названо в самом issue — у DC203 закреплён один IP, резерва по адресам для
+>   медиа нет.
+> - **#37 («прокси настроен неверно»).** В beta.7 перестала проглатываться
+>   ошибка записи секрета: раньше при неудачной записи в `%APPDATA%\TGLock`
+>   секрет молча генерировался заново при каждом запуске, и ссылка `tg://proxy`
+>   переставала совпадать с сохранённой в Telegram. Это гипотеза, а не
+>   подтверждённый диагноз — воспроизвести случай репортёра не удалось, но
+>   теперь видно, тот это случай или нет.
+> - **#39 (не работает).** По скриншоту: соединения есть, DC определяется,
+>   туннелей ноль, 678 падений маршрутов за пять минут. Наружу не отвечает ни
+>   один маршрут — у провайдера заблокирована веб-инфраструктура Telegram
+>   целиком. Кодом это не лечится, остаётся свой Cloudflare Worker. Счётчик
+>   падений маршрутов, по которому это стало видно, появился в beta.7.
+> - **#40, #41 (свои).** В LAN-режиме окно показывает готовый адрес для других
+>   устройств — люди искали его в интерфейсе и вписывали `127.0.0.1`. И страж
+>   тега в CI, который ловит тег, поставленный не на HEAD.
+> - **#42 (LAN не работает с телефона).** Нашлось в коде. Принадлежность адреса
+>   Telegram проверялась по двум первым октетам, то есть «телеграмом» считались
+>   целиком четыре `/16`, а IPv6 не распознавался вовсе. На loopback это не
+>   проявлялось: неопознанный адрес там всё равно релеится напрямую. На сетевом
+>   слушателе тот же адрес получал отказ — отсюда ровно то, что описал
+>   репортёр: на компьютере работает, с телефона нет. В beta.9 список сетей
+>   взят опубликованный Telegram, добавлены IPv6 и имена веб-инфраструктуры.
+>   Отказ перестал быть молчаливым: счётчик «Отклонено» и адрес в журнале.
+> - **#9 (Android)** остаётся открытым. PR #36 собирает APK, но приложение
+>   никто ни разу не запускал — нужен человек с телефоном.
+>
+> Общее по трём разобранным issue: во всех трёх диагноз упирался в то, что
+> программа не рассказывала о себе достаточно. Каждый выпуск с beta.7 добавлял
+> не функцию, а показание прибора.
+
 ## Выводы
 
 Главная причина жалоб «прокси подключён, но Telegram не работает» — приложение

docs/RELEASING.md

@@ -0,0 +1,74 @@
+# Как выпускать релиз
+
+## Порядок важен
+
+Токен GitHub Actions создаёт релиз **только на HEAD ветки по умолчанию**. Если тег
+отстанет от `main` хотя бы на один коммит, публикация упадёт с ошибкой
+`Resource not accessible by integration` — сообщение про права, хотя права в
+порядке и дело в положении тега.
+
+Отсюда единственное жёсткое правило: **тег ставится последним, и пока идёт
+релиз, в `main` не пушим.**
+
+## Шаги
+
+1. Влить в `main` всё, что должно попасть в релиз, и дождаться зелёного CI.
+2. Поднять версию **в двух местах** — `Cargo.toml` и `tauri.conf.json`. Они
+   должны совпадать: имена файлов бандла берутся из `tauri.conf.json`.
+3. Закоммитить подъём версии и запушить в `main`.
+4. Убедиться, что больше ничего не уедет: `git ls-remote origin refs/heads/main`
+   должен совпасть с локальным `git rev-parse HEAD`.
+5. Поставить аннотированный тег на этот же коммит и запушить его:
+
+   ```bash
+   git tag -a v2.0.0-beta.N -m "TGLock 2.0.0-beta.N"
+   git push origin v2.0.0-beta.N
+   ```
+
+6. **Ничего не пушить в `main`, пока сборка не закончится.** Правки README,
+   документации, чего угодно — после публикации релиза.
+
+## Проверить, что выпустили
+
+Зелёный workflow — это ещё не доказательство. В бетах 2 и 3 сборка была зелёной,
+а в приложение попадал headless-бинарь вместо графического. Поэтому проверяем
+содержимое, а не имя файла:
+
+```bash
+gh release download vX.Y.Z --repo by-sonic/tglock -p 'TGLock_universal.app.tar.gz' -D /tmp/check
+tar -xzf /tmp/check/TGLock_universal.app.tar.gz -C /tmp/check
+python scripts/verify_bundle_binary.py /tmp/check/TGLock.app/Contents/MacOS/tglock
+```
+
+Скрипт ищет внутри бинаря маркеры GUI (`ipc.localhost`, `wry`) и маркеры CLI
+(`allow-direct`, `secret-file`) и ругается, если в бандле оказался не тот.
+
+## Если публикация всё-таки упала с `Resource not accessible by integration`
+
+Значит, тег разошёлся с `main`. Сверьте:
+
+```bash
+git ls-remote origin refs/heads/main 'refs/tags/vX.Y.Z^{}'
+```
+
+Если SHA разные — переставьте тег на HEAD и запушьте заново:
+
+```bash
+git tag -d vX.Y.Z
+git push origin :refs/tags/vX.Y.Z
+git tag -a vX.Y.Z <sha ветки main> -m "TGLock X.Y.Z"
+git push origin vX.Y.Z
+```
+
+Перезапускать упавший workflow бесполезно: он возьмёт тот же отставший тег и
+упадёт снова.
+
+## Что защищает автоматически
+
+Первым шагом релиза идёт задача `guard`: она сверяет тег с HEAD ветки по
+умолчанию и валится за секунды, не запуская сборки. Она ловит тег, поставленный
+на старый коммит.
+
+Она **не** ловит гонку: если запушить в `main` уже после её прохождения, но до
+конца сборки, публикация упадёт. Ровно так утонул первый заход v2.0.0-beta.8.
+От этого защищает только правило из первого раздела.

package.json

@@ -1,7 +1,7 @@
 {
   "name": "tglock-ui",
   "private": true,
-  "version": "2.0.0-beta.7",
+  "version": "2.0.0-beta.13",
   "type": "module",
   "scripts": {
     "dev": "vite --port 1420",

src/bin/cli.rs

@@ -205,21 +205,33 @@ async fn watch_status(stats: Arc<proxy::Stats>) {
     let mut previous = None;
     loop {
         tokio::time::sleep(STATUS_POLL).await;
+
+        // Отдельные события — кто подключился и какой адрес отклонён. Без них
+        // journalctl показывает только счётчики, по которым нельзя отличить
+        // «телефон не дошёл» от «дошёл и получил отказ» (by-sonic/tglock#42).
+        for event in stats.drain_events() {
+            if !say(&event) {
+                return;
+            }
+        }
+
         let current = (
             stats.active.load(Ordering::Relaxed),
             stats.ws.load(Ordering::Relaxed),
-            stats.last_dc.load(Ordering::Relaxed),
-            stats.last_route.load(Ordering::Relaxed),
+            stats.last_dc(),
+            stats.last_route(),
             stats.ws_failures.load(Ordering::Relaxed),
             stats.route_failures(),
+            stats.blocked.load(Ordering::Relaxed),
+            stats.unknown_clients.load(Ordering::Relaxed),
         );
         if previous.as_ref() == Some(&current) {
             continue;
         }
-        let (active, tunnels, dc, route, failures, route_failures) = current;
+        let (active, tunnels, dc, route, failures, route_failures, blocked, unknown) = current;
         let line = format!(
             "соединений {active} · туннелей {tunnels} · {} · {} · сбоев {failures} · \
-             падений маршрутов {route_failures}",
+             падений маршрутов {route_failures} · отклонено {blocked} · не опознано {unknown}",
             if dc > 0 {
                 format!("DC{dc}")
             } else {

src/lib.rs

@@ -8,6 +8,7 @@
 pub mod config;
 pub mod mtproto;
 pub mod proxy;
+pub mod telegram_net;
 pub mod transport;
 
 /// Настройки headless-версии: файл конфигурации и сведение с флагами.

src/main.rs

@@ -47,8 +47,24 @@ struct StatusSnapshot {
     /// Падения отдельных маршрутов. Растёт даже когда соединение в итоге
     /// состоялось через запасной адрес (by-sonic/tglock#32).
     route_failures: u32,
+    /// Запросы, отклонённые политикой «в LAN-режиме только Telegram».
+    ///
+    /// Ноль при неработающем телефоне означает, что он вообще не дотянулся до
+    /// этой машины; не ноль — что дотянулся, и разбираться надо с адресами
+    /// (by-sonic/tglock#42).
+    blocked: u32,
+    /// Клиенты, которые дошли, но не сумели договориться. Почти всегда это
+    /// ссылка `tg://proxy` от прошлого запуска, то есть другой секрет.
+    unknown_clients: u32,
     uptime_seconds: u64,
     port: u16,
+    /// Адрес, который нужно вписать в Telegram на другом устройстве.
+    ///
+    /// В LAN-режиме это адрес этого компьютера в локальной сети. Люди искали
+    /// его в интерфейсе и не находили: вписывали `127.0.0.1`, который на
+    /// телефоне или в эмуляторе означает само устройство, и подключение не
+    /// работало (by-sonic/tglock#36).
+    share_address: Option<String>,
     logs: Vec<LogLine>,
 }
 
@@ -56,6 +72,10 @@ struct AppState {
     stats: Arc<proxy::Stats>,
     settings: Mutex<Settings>,
     active_port: Mutex<u16>,
+    /// Слушатель работающего прокси. Нужен, чтобы показать адрес для других
+    /// устройств именно тот, на котором прокси реально поднят, а не тот, что
+    /// сейчас выбран в настройках.
+    active_listen: Mutex<Option<ListenConfig>>,
     started_at: Mutex<Option<Instant>>,
     logs: Arc<Mutex<Vec<LogLine>>>,
     settings_path: PathBuf,
@@ -71,6 +91,7 @@ impl AppState {
             stats: proxy::Stats::new(),
             settings: Mutex::new(settings),
             active_port: Mutex::new(proxy::DEFAULT_PORT),
+            active_listen: Mutex::new(None),
             started_at: Mutex::new(None),
             logs: Arc::new(Mutex::new(Vec::new())),
             settings_path,
@@ -90,8 +111,13 @@ impl AppState {
     }
 
     fn snapshot(&self) -> StatusSnapshot {
-        let data_center = self.stats.last_dc.load(Ordering::Relaxed);
-        let route = transport::route_label(self.stats.last_route.load(Ordering::Relaxed));
+        // События прокси доходят до журнала только здесь: у ядра нет своего
+        // способа что-то показать, а интерфейс и так опрашивает состояние.
+        for event in self.stats.drain_events() {
+            self.log(event, false);
+        }
+        let data_center = self.stats.last_dc();
+        let route = transport::route_label(self.stats.last_route());
         StatusSnapshot {
             running: self.stats.running.load(Ordering::SeqCst),
             active_connections: self.stats.active.load(Ordering::Relaxed),
@@ -100,12 +126,15 @@ impl AppState {
             route: route.to_owned(),
             failures: self.stats.ws_failures.load(Ordering::Relaxed),
             route_failures: self.stats.route_failures(),
+            blocked: self.stats.blocked.load(Ordering::Relaxed),
+            unknown_clients: self.stats.unknown_clients.load(Ordering::Relaxed),
             uptime_seconds: self
                 .started_at
                 .lock()
                 .unwrap()
                 .map_or(0, |started| started.elapsed().as_secs()),
             port: *self.active_port.lock().unwrap(),
+            share_address: share_address(*self.active_listen.lock().unwrap()),
             logs: self.logs.lock().unwrap().clone(),
         }
     }
@@ -122,6 +151,18 @@ impl AppState {
     }
 }
 
+/// Адрес, который нужно вписать в Telegram на другом устройстве.
+///
+/// Только для слушателя на `0.0.0.0`: на loopback делиться нечем, туда никто
+/// извне не достучится. Возвращается адрес этой машины в сети, а не `0.0.0.0`
+/// и не `127.0.0.1` — последний на телефоне или в эмуляторе означает само
+/// устройство, и именно на этом спотыкались (by-sonic/tglock#36).
+fn share_address(listen: Option<ListenConfig>) -> Option<String> {
+    listen
+        .filter(|listen| listen.addr.ip().is_unspecified())
+        .map(|listen| format!("{}:{}", listen.advertised_host(), listen.addr.port()))
+}
+
 fn current_time() -> String {
     let seconds = SystemTime::now()
         .duration_since(UNIX_EPOCH)
@@ -177,6 +218,8 @@ fn start_proxy(state: State<'_, AppState>) -> Result<StatusSnapshot, String> {
         ListenConfig::loopback(settings.port)
     };
 
+    *state.active_listen.lock().unwrap() = Some(listen);
+
     let stats = state.stats.clone();
     let logs = state.logs.clone();
     std::thread::spawn(move || {
@@ -194,6 +237,7 @@ fn start_proxy(state: State<'_, AppState>) -> Result<StatusSnapshot, String> {
 
     std::thread::sleep(std::time::Duration::from_millis(220));
     if !state.stats.running.load(Ordering::SeqCst) {
+        *state.active_listen.lock().unwrap() = None;
         *state.started_at.lock().unwrap() = None;
         return Err(state
             .logs
@@ -213,6 +257,7 @@ fn start_proxy(state: State<'_, AppState>) -> Result<StatusSnapshot, String> {
 #[tauri::command]
 fn stop_proxy(state: State<'_, AppState>) -> StatusSnapshot {
     state.stats.stop();
+    *state.active_listen.lock().unwrap() = None;
     *state.started_at.lock().unwrap() = None;
     state.log("Защита выключена", false);
     state.snapshot()
@@ -311,6 +356,34 @@ fn main() {
 mod tests {
     use super::*;
 
+    #[test]
+    fn nothing_to_share_when_the_proxy_is_off_or_local() {
+        assert_eq!(
+            share_address(None),
+            None,
+            "выключенный прокси нечего делить"
+        );
+        assert_eq!(
+            share_address(Some(ListenConfig::loopback(1080))),
+            None,
+            "на loopback снаружи никто не подключится"
+        );
+    }
+
+    #[test]
+    fn lan_mode_shares_a_reachable_address() {
+        let shown = share_address(Some(ListenConfig::lan(1443))).expect("в LAN-режиме адрес нужен");
+        assert!(shown.ends_with(":1443"), "порт должен быть виден: {shown}");
+        assert!(
+            !shown.starts_with("0.0.0.0"),
+            "0.0.0.0 нельзя вписать в Telegram: {shown}"
+        );
+        assert!(
+            !shown.starts_with("127.0.0.1"),
+            "127.0.0.1 на другом устройстве означает само устройство: {shown}"
+        );
+    }
+
     #[test]
     fn software_rendering_is_requested_by_default() {
         let vars = software_rendering_vars(false, |_| false);

src/mtproto.rs

@@ -43,6 +43,49 @@ impl CryptoContext {
         self.telegram_decrypt.apply_keystream(data);
         self.client_encrypt.apply_keystream(data);
     }
+
+    /// Разделить шифры по направлениям, чтобы туннель шёл в обе стороны сразу.
+    ///
+    /// Направления независимы: это два потока AES-CTR со своими ключами, и ни
+    /// один байт одного не влияет на другой.
+    pub fn split(self) -> (Upstream, Downstream) {
+        (
+            Upstream {
+                client_decrypt: self.client_decrypt,
+                telegram_encrypt: self.telegram_encrypt,
+            },
+            Downstream {
+                telegram_decrypt: self.telegram_decrypt,
+                client_encrypt: self.client_encrypt,
+            },
+        )
+    }
+}
+
+/// Шифры направления «клиент -> Telegram».
+pub struct Upstream {
+    client_decrypt: AesCtr,
+    telegram_encrypt: AesCtr,
+}
+
+impl Upstream {
+    pub fn apply(&mut self, data: &mut [u8]) {
+        self.client_decrypt.apply_keystream(data);
+        self.telegram_encrypt.apply_keystream(data);
+    }
+}
+
+/// Шифры направления «Telegram -> клиент».
+pub struct Downstream {
+    telegram_decrypt: AesCtr,
+    client_encrypt: AesCtr,
+}
+
+impl Downstream {
+    pub fn apply(&mut self, data: &mut [u8]) {
+        self.telegram_decrypt.apply_keystream(data);
+        self.client_encrypt.apply_keystream(data);
+    }
 }
 
 pub fn generate_secret() -> [u8; 16] {

src/telegram_net.rs

@@ -0,0 +1,271 @@
+//! Какие адреса и имена принадлежат Telegram.
+//!
+//! От этого ответа зависит поведение LAN-режима: слушатель на сетевом адресе
+//! пропускает только Telegram, всё остальное отклоняет. Значит ошибка в любую
+//! сторону видна пользователю.
+//!
+//! Раньше проверка сравнивала два первых октета, то есть считала «телеграмом»
+//! целиком `149.154.0.0/16`, `91.108.0.0/16`, `91.105.0.0/16` и `185.76.0.0/16`,
+//! а IPv6 не знала вовсе. Отсюда два разных дефекта: чужие адреса внутри этих
+//! сетей уходили в MTProto-туннель и умирали, а настоящие адреса Telegram по
+//! IPv6 отклонялись как посторонние. Второе и выглядит как «на компьютере
+//! работает, с телефона нет» (by-sonic/tglock#42): на loopback не-Telegram
+//! адреса всё равно релеятся напрямую, поэтому там ошибка не проявляется.
+//!
+//! Список сетей — официальный, <https://core.telegram.org/resources/cidr.txt>,
+//! сверен 19 августа 2026 года.
+
+use std::net::{IpAddr, Ipv4Addr, Ipv6Addr};
+
+/// IPv4-сети Telegram: адрес сети и длина префикса.
+const V4: &[(Ipv4Addr, u32)] = &[
+    (Ipv4Addr::new(91, 105, 192, 0), 23),
+    (Ipv4Addr::new(91, 108, 4, 0), 22),
+    (Ipv4Addr::new(91, 108, 8, 0), 22),
+    (Ipv4Addr::new(91, 108, 12, 0), 22),
+    (Ipv4Addr::new(91, 108, 16, 0), 22),
+    (Ipv4Addr::new(91, 108, 20, 0), 22),
+    (Ipv4Addr::new(91, 108, 56, 0), 22),
+    (Ipv4Addr::new(149, 154, 160, 0), 20),
+    (Ipv4Addr::new(185, 76, 151, 0), 24),
+];
+
+/// IPv6-сети Telegram.
+const V6: &[(Ipv6Addr, u32)] = &[
+    (Ipv6Addr::new(0x2001, 0x67c, 0x4e8, 0, 0, 0, 0, 0), 48),
+    (Ipv6Addr::new(0x2001, 0xb28, 0xf23c, 0, 0, 0, 0, 0), 48),
+    (Ipv6Addr::new(0x2001, 0xb28, 0xf23d, 0, 0, 0, 0, 0), 48),
+    (Ipv6Addr::new(0x2001, 0xb28, 0xf23f, 0, 0, 0, 0, 0), 48),
+    (Ipv6Addr::new(0x2a0a, 0xf280, 0, 0, 0, 0, 0, 0), 32),
+];
+
+/// Домены Telegram, к которым SOCKS5-клиент может попроситься по имени.
+///
+/// Это веб-инфраструктура, а не дата-центры: обычный HTTPS, MTProto в нём нет.
+/// Telegram ходит сюда за конфигурацией, превью ссылок и файлами CDN, и на
+/// телефоне такие запросы идут через тот же прокси.
+const HOSTS: &[&str] = &[
+    "telegram.org",
+    "t.me",
+    "telegram.me",
+    "telesco.pe",
+    "cdn-telegram.org",
+];
+
+/// Принадлежит ли адрес Telegram.
+pub fn is_telegram(ip: IpAddr) -> bool {
+    match ip {
+        IpAddr::V4(ip) => in_v4(ip),
+        // Клиент может прислать `::ffff:149.154.167.51` вместо IPv4-формы, и
+        // это тот же самый адрес.
+        IpAddr::V6(ip) => match ip.to_ipv4_mapped() {
+            Some(ip) => in_v4(ip),
+            None => in_v6(ip),
+        },
+    }
+}
+
+/// Принадлежит ли имя Telegram.
+///
+/// Совпадение только по границе метки: `telegram.org.example.com` — чужой
+/// домен, и разрешать его нельзя.
+pub fn is_telegram_host(host: &str) -> bool {
+    let host = host.trim_end_matches('.').to_ascii_lowercase();
+    HOSTS.iter().any(|suffix| {
+        host == *suffix
+            || (host.len() > suffix.len()
+                && host.ends_with(suffix)
+                && host.as_bytes()[host.len() - suffix.len() - 1] == b'.')
+    })
+}
+
+/// Номер дата-центра по адресу — запасной вариант, когда его не удалось
+/// достать из init-пакета.
+///
+/// Это догадка, а не факт: одна и та же подсеть обслуживает несколько DC
+/// (`149.154.175.x` — и DC1, и DC3). Настоящий номер приходит из init, и сюда
+/// попадают только соединения, у которых init разобрать не вышло.
+pub fn dc_from_ip(ip: IpAddr) -> Option<u16> {
+    match ip {
+        IpAddr::V4(ip) => dc_from_ipv4(ip),
+        IpAddr::V6(ip) => match ip.to_ipv4_mapped() {
+            Some(ip) => dc_from_ipv4(ip),
+            None => dc_from_ipv6(ip),
+        },
+    }
+}
+
+fn dc_from_ipv4(ip: Ipv4Addr) -> Option<u16> {
+    if !in_v4(ip) {
+        return None;
+    }
+    let octets = ip.octets();
+    Some(match (octets[0], octets[1], octets[2]) {
+        (149, 154, 160..=163) => 1,
+        (149, 154, 164..=167) => 2,
+        (149, 154, 168..=171) => 3,
+        (149, 154, 172..=175) => 1,
+        (91, 108, 56..=59) => 5,
+        (91, 108, 8..=11) => 3,
+        (91, 108, 12..=15) => 4,
+        (91, 105, 192..=193) => 203,
+        _ => 2,
+    })
+}
+
+/// Адреса дата-центров имеют вид `2001:b28:f23d:f002::a`, где `f00N` —
+/// номер DC. Для `2a0a:f280::/32` такого правила нет, и выдумывать его не
+/// нужно: номер придёт из init.
+fn dc_from_ipv6(ip: Ipv6Addr) -> Option<u16> {
+    if !in_v6(ip) {
+        return None;
+    }
+    let dc = ip.segments()[3].checked_sub(0xf000)?;
+    matches!(dc, 1..=5).then_some(dc)
+}
+
+fn in_v4(ip: Ipv4Addr) -> bool {
+    let value = u32::from(ip);
+    V4.iter().any(|&(network, prefix)| {
+        let mask = u32::MAX.checked_shl(32 - prefix).unwrap_or(0);
+        value & mask == u32::from(network) & mask
+    })
+}
+
+fn in_v6(ip: Ipv6Addr) -> bool {
+    let value = u128::from(ip);
+    V6.iter().any(|&(network, prefix)| {
+        let mask = u128::MAX.checked_shl(128 - prefix).unwrap_or(0);
+        value & mask == u128::from(network) & mask
+    })
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    fn ip(value: &str) -> IpAddr {
+        value.parse().unwrap()
+    }
+
+    #[test]
+    fn known_data_centre_addresses_are_telegram() {
+        for address in [
+            "149.154.175.50", // DC1
+            "149.154.167.51", // DC2
+            "149.154.175.100",
+            "149.154.167.91",
+            "91.108.56.130", // DC5
+            "91.105.192.100",
+            "185.76.151.1",
+        ] {
+            assert!(is_telegram(ip(address)), "{address} принадлежит Telegram");
+        }
+    }
+
+    /// Раньше сюда попадал весь `/16`, то есть десятки тысяч чужих адресов.
+    #[test]
+    fn neighbours_outside_the_published_blocks_are_not_telegram() {
+        for address in [
+            "149.154.159.255", // на один адрес ниже 149.154.160.0/20
+            "149.154.176.0",   // на один выше
+            "91.108.3.255",
+            "91.108.24.0",
+            "91.108.60.0",
+            "91.105.194.0",
+            "185.76.150.255",
+            "185.76.152.0",
+            "1.1.1.1",
+        ] {
+            assert!(!is_telegram(ip(address)), "{address} — не Telegram");
+        }
+    }
+
+    #[test]
+    fn block_edges_belong_to_the_block() {
+        for address in [
+            "149.154.160.0",
+            "149.154.175.255",
+            "91.108.4.0",
+            "91.108.7.255",
+            "185.76.151.0",
+            "185.76.151.255",
+        ] {
+            assert!(is_telegram(ip(address)), "{address} — край блока Telegram");
+        }
+    }
+
+    /// Из-за этого LAN-режим отклонял живой Telegram (by-sonic/tglock#42).
+    #[test]
+    fn ipv6_data_centres_are_telegram_too() {
+        for address in [
+            "2001:b28:f23d:f001::a",
+            "2001:67c:4e8:f002::a",
+            "2001:b28:f23d:f003::a",
+            "2001:67c:4e8:f004::a",
+            "2001:b28:f23f:f005::a",
+            "2001:b28:f23c::1",
+            "2a0a:f280:203:a::b",
+        ] {
+            assert!(is_telegram(ip(address)), "{address} принадлежит Telegram");
+        }
+        assert!(!is_telegram(ip("2606:4700:4700::1111")), "это Cloudflare");
+        assert!(!is_telegram(ip("2001:b28:f23e::1")), "соседний префикс");
+    }
+
+    #[test]
+    fn ipv4_mapped_form_is_the_same_address() {
+        assert!(is_telegram(ip("::ffff:149.154.167.51")));
+        assert!(!is_telegram(ip("::ffff:1.1.1.1")));
+    }
+
+    /// Поведение, на которое опирался предыдущий тест `dc_from_ip`.
+    #[test]
+    fn data_centre_guess_survives_the_stricter_membership_check() {
+        assert_eq!(dc_from_ip(ip("149.154.160.1")), Some(1));
+        assert_eq!(dc_from_ip(ip("149.154.167.255")), Some(2));
+        assert_eq!(dc_from_ip(ip("91.108.58.1")), Some(5));
+        assert_eq!(dc_from_ip(ip("1.1.1.1")), None);
+    }
+
+    #[test]
+    fn data_centre_guess_reads_the_number_out_of_an_ipv6_address() {
+        assert_eq!(dc_from_ip(ip("2001:67c:4e8:f002::a")), Some(2));
+        assert_eq!(dc_from_ip(ip("2001:b28:f23f:f005::a")), Some(5));
+        assert_eq!(
+            dc_from_ip(ip("2a0a:f280:203:a::b")),
+            None,
+            "для этого префикса правила нет — лучше признаться, чем выдумать"
+        );
+    }
+
+    #[test]
+    fn telegram_hosts_are_matched_on_label_boundaries() {
+        for host in [
+            "telegram.org",
+            "web.telegram.org",
+            "core.telegram.org",
+            "venus.web.telegram.org",
+            "t.me",
+            "TELEGRAM.ORG",
+            "telegram.org.", // корневая точка в имени законна
+            "cdn4.cdn-telegram.org",
+        ] {
+            assert!(is_telegram_host(host), "{host} — Telegram");
+        }
+    }
+
+    #[test]
+    fn lookalike_hosts_are_rejected() {
+        for host in [
+            "telegram.org.example.com",
+            "nottelegram.org",
+            "fakecdn-telegram.org",
+            "t.me.evil.net",
+            "example.com",
+            "",
+        ] {
+            assert!(!is_telegram_host(host), "{host} — не Telegram");
+        }
+    }
+}

src/transport.rs

@@ -87,6 +87,15 @@ impl Route {
     }
 }
 
+/// Что случилось с доменами Worker'а, которые задал пользователь.
+#[derive(Clone, Debug, Default, Eq, PartialEq)]
+pub struct WorkerDomains {
+    /// Домены, попавшие в список маршрутов.
+    pub accepted: Vec<String>,
+    /// Строки, не похожие на имя хоста, — маршрута из них не вышло.
+    pub rejected: Vec<String>,
+}
+
 #[derive(Clone, Debug)]
 pub struct ConnectedRoute {
     pub route: Route,
@@ -151,15 +160,29 @@ impl TransportEngine {
         Self::default()
     }
 
-    pub fn set_worker_domains(&self, domains: &[String]) {
-        let mut normalized = Vec::new();
+    /// Задать домены Worker'ов, вернув принятые и отвергнутые по отдельности.
+    ///
+    /// Отвергнутые возвращаются, потому что раньше они отбрасывались молча:
+    /// вписанный со схемой или слэшем `https://name.workers.dev/` не проходил
+    /// проверку, маршрут не появлялся, и «воркер настроен» ничем не отличалось
+    /// от «воркера нет» (by-sonic/tglock#50).
+    pub fn set_worker_domains(&self, domains: &[String]) -> WorkerDomains {
+        let mut accepted = Vec::new();
+        let mut rejected = Vec::new();
         for domain in domains {
-            let domain = domain.trim().to_ascii_lowercase();
-            if valid_domain(&domain) && !normalized.contains(&domain) {
-                normalized.push(domain);
+            let trimmed = domain.trim();
+            if trimmed.is_empty() {
+                continue;
+            }
+            let normalized = trimmed.to_ascii_lowercase();
+            if !valid_domain(&normalized) {
+                rejected.push(trimmed.to_owned());
+            } else if !accepted.contains(&normalized) {
+                accepted.push(normalized);
             }
         }
-        *self.worker_domains.lock().unwrap() = normalized;
+        *self.worker_domains.lock().unwrap() = accepted.clone();
+        WorkerDomains { accepted, rejected }
     }
 
     pub async fn connect(
@@ -179,18 +202,22 @@ impl TransportEngine {
                 }
                 Err(error) => {
                     self.record_failure(&route);
-                    errors.push(format!(
-                        "{} via {}: {}",
-                        route.websocket_host, route.connect_host, error
-                    ));
+                    let attempt = format!("{} — {}", route.connect_host, error);
+                    if !errors.contains(&attempt) {
+                        errors.push(attempt);
+                    }
                 }
             }
         }
 
+        // Текст читает человек: он попадает в журнал событий, и по нему
+        // отличают «провайдер режет закреплённые адреса» от «воркер отвечает
+        // отказом». Раньше причина отказа не доходила никуда, и при
+        // `туннелей 0` узнать, почему их ноль, было нечем (by-sonic/tglock#50).
         Err(format!(
-            "all Telegram routes for DC{}{} failed: {}",
+            "Не поднялся туннель до DC{}{}: {}",
             dc,
-            if media { " media" } else { "" },
+            if media { " (медиа)" } else { "" },
             errors.join("; ")
         ))
     }
@@ -376,8 +403,8 @@ async fn connect_route(route: &Route) -> Result<TelegramWebSocket, String> {
         TcpStream::connect((route.connect_host.as_str(), route.port)),
     )
     .await
-    .map_err(|_| "TCP connect timeout".to_owned())?
-    .map_err(|error| format!("TCP connect: {}", error))?;
+    .map_err(|_| "не отвечает (таймаут TCP)".to_owned())?
+    .map_err(|error| format!("соединение не открылось: {}", error))?;
     tcp.set_nodelay(true)
         .map_err(|error| format!("TCP_NODELAY: {}", error))?;
 
@@ -402,9 +429,9 @@ async fn connect_route(route: &Route) -> Result<TelegramWebSocket, String> {
             tokio_tungstenite::client_async(request, MaybeTlsStream::Plain(tcp)),
         )
         .await
-        .map_err(|_| "WebSocket timeout".to_owned())?
+        .map_err(|_| "таймаут WebSocket".to_owned())?
         .map(|(websocket, _)| websocket)
-        .map_err(|error| format!("WebSocket handshake: {}", error));
+        .map_err(|error| format!("рукопожатие WebSocket: {}", error));
     }
 
     // The URI host remains the real Telegram hostname even when the TCP socket
@@ -417,7 +444,7 @@ async fn connect_route(route: &Route) -> Result<TelegramWebSocket, String> {
         tokio_tungstenite::client_async_tls_with_config(request, tcp, None, Some(connector)),
     )
     .await
-    .map_err(|_| "TLS/WebSocket timeout".to_owned())?
+    .map_err(|_| "таймаут TLS/WebSocket".to_owned())?
     .map(|(websocket, _)| websocket)
     .map_err(|error| format!("TLS/WebSocket handshake: {}", error))
 }
@@ -612,7 +639,7 @@ mod tests {
     #[test]
     fn worker_domains_are_rejected_unless_they_are_plain_hostnames() {
         let engine = TransportEngine::new();
-        engine.set_worker_domains(&[
+        let result = engine.set_worker_domains(&[
             "https://scheme.workers.dev".to_owned(),
             "with.a/path".to_owned(),
             "no-dot".to_owned(),
@@ -633,6 +660,17 @@ mod tests {
             .filter(|route| route.kind == RouteKind::CloudflareWorker)
             .collect();
         assert_eq!(workers.len(), 1, "only the valid hostname may survive");
+        assert_eq!(result.accepted, vec!["good.workers.dev".to_owned()]);
+        assert!(
+            result.rejected.contains(&"https://scheme.workers.dev".to_owned()),
+            "отвергнутая строка обязана вернуться названной, иначе о ней некому              сообщить: {:?}",
+            result.rejected
+        );
+        assert!(
+            !result.rejected.iter().any(String::is_empty),
+            "пустая строка — не то, о чём стоит предупреждать: {:?}",
+            result.rejected
+        );
         assert_eq!(workers[0].websocket_host, "good.workers.dev");
     }
 

tauri.conf.json

@@ -1,7 +1,7 @@
 {
   "$schema": "https://schema.tauri.app/config/2",
   "productName": "TGLock",
-  "version": "2.0.0-beta.7",
+  "version": "2.0.0-beta.13",
   "identifier": "com.bysonic.tglock",
   "mainBinaryName": "tglock",
   "build": {

ui/main.ts

@@ -11,8 +11,14 @@ type Status = {
   route: string;
   failures: number;
   routeFailures: number;
+  /// Отклонено политикой «в LAN-режиме только Telegram».
+  blocked: number;
+  /// Клиенты, которые дошли, но не сумели договориться о рукопожатии.
+  unknownClients: number;
   uptimeSeconds: number;
   port: number;
+  /// Адрес для других устройств. Приходит только в LAN-режиме.
+  shareAddress: string | null;
   logs: LogLine[];
 };
 
@@ -39,8 +45,11 @@ let status: Status = {
   route: "Маршрут ещё не выбран",
   failures: 0,
   routeFailures: 0,
+  blocked: 0,
+  unknownClients: 0,
   uptimeSeconds: 0,
   port: 1080,
+  shareAddress: null,
   logs: [],
 };
 let settings: Settings = { lanMode: false, port: 1080, workerDomain: "" };
@@ -147,6 +156,18 @@ function renderHome(): void {
         <span>порт ${status.port}</span>
       </div>
 
+      ${status.shareAddress ? `
+      <div class="share-card">
+        <div class="share-label">Адрес для других устройств</div>
+        <button id="copy-address" class="share-address" title="Нажмите, чтобы скопировать">
+          ${escapeHtml(status.shareAddress)}
+        </button>
+        <div class="share-hint">
+          Впишите его в Telegram на телефоне. Не <code>127.0.0.1</code> — на другом
+          устройстве это означает само устройство.
+        </div>
+      </div>` : ""}
+
       <nav class="bottom-nav" aria-label="Разделы">
         <button id="settings-nav" class="nav-button">
           <span class="nav-icon">${icons.settings}</span>
@@ -162,6 +183,7 @@ function renderHome(): void {
   `, "home-page");
 
   document.querySelector("#power")?.addEventListener("click", toggleProtection);
+  document.querySelector("#copy-address")?.addEventListener("click", copyShareAddress);
   document.querySelector("#settings-nav")?.addEventListener("click", () => navigate("settings"));
   document.querySelector("#diagnostics-nav")?.addEventListener("click", () => navigate("diagnostics"));
 }
@@ -267,6 +289,14 @@ function renderDiagnostics(): void {
           <span>Падений маршрутов</span>
           <strong>${status.routeFailures}</strong>
         </article>
+        <article class="metric-card">
+          <span>Отклонено</span>
+          <strong>${status.blocked}</strong>
+        </article>
+        <article class="metric-card">
+          <span>Не опознаны</span>
+          <strong>${status.unknownClients}</strong>
+        </article>
       </div>
 
       <p class="field-hint">
@@ -275,6 +305,20 @@ function renderDiagnostics(): void {
         Число в багрепорте помогает понять, что именно перебиралось.
       </p>
 
+      <p class="field-hint">
+        «Отклонено» — запросы, которые LAN-режим не пропустил: он ходит только
+        по адресам Telegram. Если с телефона ничего не работает, а здесь ноль и
+        соединений тоже ноль, значит телефон до этого компьютера не дошёл —
+        дело в сети или брандмауэре. Какие именно адреса отклонены, видно ниже.
+      </p>
+
+      <p class="field-hint">
+        «Не опознаны» — клиенты, которые дошли до прокси, но договориться с ними
+        не удалось. Почти всегда это старая ссылка: секрет в Telegram остался от
+        прошлого запуска и больше не совпадает. Тогда Telegram пишет «прокси
+        настроен неверно», а адрес такого клиента появится в журнале ниже.
+      </p>
+
       <div class="log-panel">
         <div class="log-heading">
           <span>Последние события</span>
@@ -368,6 +412,18 @@ async function saveSettings(event: Event): Promise<void> {
   }
 }
 
+async function copyShareAddress(): Promise<void> {
+  const address = status.shareAddress;
+  if (!address) return;
+  try {
+    await navigator.clipboard.writeText(address);
+    showToast("Адрес скопирован");
+  } catch {
+    // Буфер обмена может быть недоступен — адрес и так виден на экране.
+    showToast("Скопируйте адрес вручную", true);
+  }
+}
+
 function showToast(message: string, error = false): void {
   window.clearTimeout(toastTimer);
   window.requestAnimationFrame(() => {

ui/styles.css

@@ -847,3 +847,53 @@ input:disabled {
       0 19px 52px rgba(9, 182, 133, 0.4);
   }
 }
+
+/* Адрес для подключения других устройств. Показывается только в LAN-режиме:
+   люди искали его в интерфейсе, не находили и вписывали 127.0.0.1, который на
+   телефоне означает сам телефон (by-sonic/tglock#36). */
+.share-card {
+  margin-top: 14px;
+  padding: 14px 16px;
+  border-radius: 14px;
+  background: rgba(42, 171, 238, 0.08);
+  border: 1px solid rgba(42, 171, 238, 0.24);
+  text-align: center;
+}
+
+.share-label {
+  font-size: 12px;
+  letter-spacing: 0.02em;
+  color: var(--text-muted, #8b949e);
+}
+
+.share-address {
+  display: block;
+  width: 100%;
+  margin: 6px 0 8px;
+  padding: 6px 8px;
+  border: 0;
+  border-radius: 10px;
+  background: transparent;
+  color: var(--accent, #2aabee);
+  font-family: ui-monospace, SFMono-Regular, Menlo, Consolas, monospace;
+  font-size: 20px;
+  font-weight: 600;
+  cursor: pointer;
+  transition: background 150ms ease;
+}
+
+.share-address:hover,
+.share-address:focus-visible {
+  background: rgba(42, 171, 238, 0.14);
+}
+
+.share-hint {
+  font-size: 11px;
+  line-height: 1.45;
+  color: var(--text-muted, #8b949e);
+}
+
+.share-hint code {
+  font-family: ui-monospace, SFMono-Regular, Menlo, Consolas, monospace;
+  font-size: 11px;
+}