chore(release): 2.0.0-beta.6

Файл настроек для headless-версии (#32, #35) и исправление падения демона при
закрытом stdout.

.github/workflows/ci.yml

@@ -0,0 +1,212 @@
+name: CI
+
+on:
+  push:
+    branches: [main]
+  pull_request:
+
+permissions:
+  contents: read
+
+jobs:
+  rust:
+    name: Rust checks
+    runs-on: macos-latest
+    steps:
+      - uses: actions/checkout@v6
+
+      - name: Install Node.js
+        uses: actions/setup-node@v6
+        with:
+          node-version: 22
+          cache: npm
+
+      - name: Build frontend
+        run: npm ci && npm run build
+
+      - name: Install Rust
+        uses: dtolnay/rust-toolchain@stable
+        with:
+          components: rustfmt, clippy
+
+      # Оба бинаря лежат в одном крейте, и бандлер Tauri без явного указания
+      # может взять headless CLI как главный исполняемый файл приложения.
+      # Именно это уехало в v2.0.0-beta.2: .app и .deb содержали tglock-cli, и
+      # приложение не открывалось ни на одной платформе.
+      - name: Main binary of the bundle must be the GUI one
+        run: |
+          node -e "
+          const fs = require('fs');
+          const conf = JSON.parse(fs.readFileSync('tauri.conf.json', 'utf8'));
+          const toml = fs.readFileSync('Cargo.toml', 'utf8');
+          const gui = toml.split('[[bin]]').slice(1)
+            .find(b => /required-features\s*=\s*\[\s*\"gui\"\s*\]/.test(b));
+          if (!gui) throw new Error('не найден [[bin]] с required-features = [\"gui\"]');
+          const name = (gui.match(/name\s*=\s*\"([^\"]+)\"/) || [])[1];
+          if (conf.mainBinaryName !== name) {
+            throw new Error('mainBinaryName=' + conf.mainBinaryName + ', а GUI-бинарь называется ' + name);
+          }
+          console.log('mainBinaryName указывает на GUI-бинарь:', name);
+          "
+
+      - name: Check formatting
+        run: cargo fmt --check
+
+      - name: Lint
+        run: cargo clippy --all-targets -- -D warnings
+
+      - name: Test
+        run: cargo test --all-targets
+
+  bundle:
+    name: Bundled app must be the GUI binary
+    runs-on: macos-latest
+    steps:
+      - uses: actions/checkout@v6
+
+      - name: Install Node.js
+        uses: actions/setup-node@v6
+        with:
+          node-version: 22
+          cache: npm
+
+      - name: Install frontend dependencies
+        run: npm ci
+
+      - name: Install Rust
+        uses: dtolnay/rust-toolchain@stable
+        with:
+          targets: aarch64-apple-darwin
+
+      # Явный --target обязателен: без него бандлер выбирал правильный бинарь, а
+      # с ним — нет, и именно так beta.2 и beta.3 уехали с headless CLI внутри.
+      - name: Bundle the app
+        run: npx tauri build --bundles app --target aarch64-apple-darwin
+
+      # Проверяется содержимое, а не имя файла. В beta.3 имя было уже
+      # правильным, потому что бандлер переименовал CLI, и проверка имени
+      # ничего не заметила.
+      - name: The bundled binary must actually be the GUI one
+        run: |
+          exe=$(find target -maxdepth 8 -path '*TGLock.app/Contents/MacOS/tglock' | head -1)
+          test -n "$exe" || { echo "исполняемый файл бандла не найден"; find target -maxdepth 6 -name 'TGLock.app'; exit 1; }
+          python3 scripts/verify_bundle_binary.py "$exe"
+
+  headless:
+    name: Headless CLI (no WebView, no Node)
+    runs-on: ubuntu-22.04
+    steps:
+      - uses: actions/checkout@v6
+
+      - name: Install Rust
+        uses: dtolnay/rust-toolchain@stable
+        with:
+          components: clippy
+
+      # This job deliberately installs no Node.js, no frontend and no
+      # libwebkit2gtk. It fails the moment anything drags the GUI back into the
+      # headless build, which is the whole point of issues #10 and #17.
+      - name: Lint
+        run: cargo clippy --no-default-features --features cli --all-targets -- -D warnings
+
+      - name: Test
+        run: cargo test --no-default-features --features cli --lib --bins
+
+      - name: Build
+        run: cargo build --release --no-default-features --features cli --bin tglock-cli
+
+      - name: Start, advertise a proxy link and stop on SIGTERM
+        run: |
+          ./target/release/tglock-cli --help
+          ./target/release/tglock-cli --version
+          # --preserve-status makes this assert the shutdown path: a handled
+          # SIGTERM exits 0, an unhandled one would surface as 143 and fail.
+          timeout --preserve-status --signal=TERM 5 \
+            ./target/release/tglock-cli --port 18080 --secret-file "$PWD/secret" > cli.log 2>&1
+          cat cli.log
+          grep -q 'tg://proxy' cli.log
+          grep -q '127.0.0.1:18080' cli.log
+          test "$(stat -c '%a' "$PWD/secret")" = 600
+
+      - name: Keep the same proxy link across a restart
+        run: |
+          first=$(grep -o 'secret=[0-9a-f]*' cli.log)
+          timeout --preserve-status --signal=TERM 5 \
+            ./target/release/tglock-cli --port 18080 --secret-file "$PWD/secret" > restart.log 2>&1
+          test "$first" = "$(grep -o 'secret=[0-9a-f]*' restart.log)"
+
+      # Настройки из файла и приоритет флага над файлом.
+      - name: Read settings from a file
+        run: |
+          cat > tglock.toml <<'CONF'
+          port = 18090
+          secret = "dd00112233445566778899aabbccddeeff"
+          worker = ["example.workers.dev"]
+          CONF
+          timeout --preserve-status --signal=TERM 5 \
+            ./target/release/tglock-cli --config tglock.toml > conf.log 2>&1
+          cat conf.log
+          grep -q '127.0.0.1:18090' conf.log
+          grep -q 'secret=dd00112233445566778899aabbccddeeff' conf.log
+          grep -q 'example.workers.dev' conf.log
+          # Флаг должен перекрывать файл.
+          timeout --preserve-status --signal=TERM 5 \
+            ./target/release/tglock-cli --config tglock.toml --port 18091 > over.log 2>&1
+          grep -q '127.0.0.1:18091' over.log
+          # Опечатка в файле обязана быть ошибкой, а не молчаливым дефолтом.
+          echo 'porrt = 1443' > bad.toml
+          if ./target/release/tglock-cli --config bad.toml; then
+            echo "опечатка в конфиге прошла незамеченной"; exit 1
+          fi
+
+      # Закрытый stdout не должен ронять демон: println! при ошибке записи
+      # паникует, а канал закрывается штатно — `| head`, закрытый терминал,
+      # перезапуск сборщика логов.
+      - name: Survive a closed stdout
+        run: |
+          set +e
+          timeout --signal=TERM 5 ./target/release/tglock-cli --port 18092 2> pipe-err.log | head -2
+          set -e
+          cat pipe-err.log
+          if grep -qi 'panic' pipe-err.log; then
+            echo "демон упал из-за закрытого stdout"; exit 1
+          fi
+
+  msrv:
+    name: Rust 1.88 compatibility
+    runs-on: macos-latest
+    steps:
+      - uses: actions/checkout@v6
+
+      - name: Install Node.js
+        uses: actions/setup-node@v6
+        with:
+          node-version: 22
+          cache: npm
+
+      - name: Build frontend
+        run: npm ci && npm run build
+
+      - name: Install minimum supported Rust
+        uses: dtolnay/rust-toolchain@1.88.0
+
+      - name: Check locked dependency graph
+        run: cargo check --locked
+
+      - name: Check the headless dependency graph too
+        run: cargo check --locked --no-default-features --features cli --lib --bins
+
+  frontend:
+    name: Frontend
+    runs-on: macos-latest
+    steps:
+      - uses: actions/checkout@v6
+
+      - name: Install Node.js
+        uses: actions/setup-node@v6
+        with:
+          node-version: 22
+          cache: npm
+
+      - name: Type-check and build
+        run: npm ci && npm run build

.github/workflows/release.yml

@@ -1,83 +1,173 @@
 name: Release
 
 on:
+  workflow_dispatch:
   push:
-    tags: ['v*']
+    tags: ["v*"]
 
 permissions:
   contents: write
 
 jobs:
-  build:
+  publish:
+    name: Build ${{ matrix.platform }}
     strategy:
+      fail-fast: false
       matrix:
         include:
-          - os: windows-latest
-            target: x86_64-pc-windows-msvc
-            artifact: tglock.exe
-          - os: macos-latest
-            target: x86_64-apple-darwin
-            artifact: tglock-macos-x64
-          - os: macos-latest
-            target: aarch64-apple-darwin
-            artifact: tglock-macos-arm64
-          - os: ubuntu-latest
-            target: x86_64-unknown-linux-gnu
-            artifact: tglock-linux-x64
+          - platform: macOS universal
+            os: macos-14
+            args: --bundles app,dmg --target universal-apple-darwin
+            rust-targets: aarch64-apple-darwin,x86_64-apple-darwin
+          - platform: Windows x64
+            os: windows-latest
+            args: --bundles nsis --target x86_64-pc-windows-msvc
+            rust-targets: x86_64-pc-windows-msvc
+          - platform: Linux x64
+            os: ubuntu-22.04
+            args: --bundles appimage,deb --target x86_64-unknown-linux-gnu
+            rust-targets: x86_64-unknown-linux-gnu
 
     runs-on: ${{ matrix.os }}
 
     steps:
-      - uses: actions/checkout@v4
+      - uses: actions/checkout@v6
+
+      - name: Install Linux desktop dependencies
+        if: runner.os == 'Linux'
+        run: |
+          sudo apt-get update
+          sudo apt-get install -y \
+            libwebkit2gtk-4.1-dev \
+            libappindicator3-dev \
+            librsvg2-dev \
+            patchelf
+
+      - name: Install Node.js
+        uses: actions/setup-node@v6
+        with:
+          node-version: 22
+          cache: npm
 
       - name: Install Rust
         uses: dtolnay/rust-toolchain@stable
         with:
-          targets: ${{ matrix.target }}
+          targets: ${{ matrix.rust-targets }}
 
-      - name: Build
-        run: cargo build --release --target ${{ matrix.target }}
+      - name: Install frontend dependencies
+        run: npm ci
 
-      - name: Rename (Unix)
-        if: runner.os != 'Windows'
-        run: cp target/${{ matrix.target }}/release/tglock ${{ matrix.artifact }}
-
-      - name: Rename (Windows)
-        if: runner.os == 'Windows'
-        run: copy target\${{ matrix.target }}\release\tglock.exe ${{ matrix.artifact }}
-
-      - name: Upload
-        uses: actions/upload-artifact@v4
+      - name: Build and publish release
+        uses: tauri-apps/tauri-action@v0
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
         with:
-          name: ${{ matrix.artifact }}
-          path: ${{ matrix.artifact }}
+          tagName: v__VERSION__
+          releaseName: TGLock v__VERSION__
+          releaseBody: |
+            Новый TGLock: адаптивный MTProto/WebSocket-транспорт и полностью обновлённый интерфейс на Tauri 2.
+
+            - macOS: скачайте универсальный `.dmg` или `.app.tar.gz`
+            - Windows: скачайте `.exe` установщик
+            - Linux: скачайте `.AppImage` или `.deb`
+            - Сервер или машина без монитора: скачайте `tglock-cli-*` — там нет графического интерфейса
+          releaseDraft: false
+          prerelease: false
+          args: ${{ matrix.args }}
+
+      # Проверяет СОДЕРЖИМОЕ упакованного бинаря, а не его имя.
+      #
+      # v2.0.0-beta.2 и v2.0.0-beta.3 опубликовались с зелёным CI, хотя в бандле
+      # лежал headless CLI вместо приложения. В beta.3 имя файла было уже
+      # правильным — переименованным — поэтому проверка имени прошла. Отличить
+      # можно только по содержимому: `wry`/`ipc.localhost` есть исключительно в
+      # GUI, а `allow-direct` — исключительно в CLI.
+      - name: The bundled binary must actually be the GUI one
+        if: runner.os == 'macOS'
+        shell: bash
+        run: |
+          app=$(find target -maxdepth 6 -name 'TGLock.app' -type d | head -1)
+          test -n "$app" || { echo "TGLock.app не найден"; exit 1; }
+          exe="$app/Contents/MacOS/tglock"
+          test -f "$exe" || { echo "нет $exe:"; ls -la "$app/Contents/MacOS/"; exit 1; }
+          python3 scripts/verify_bundle_binary.py "$exe"
+
+      - name: The bundled binary must actually be the GUI one
+        if: runner.os == 'Linux'
+        shell: bash
+        run: |
+          deb=$(find target -maxdepth 6 -name '*.deb' | head -1)
+          test -n "$deb" || { echo ".deb не найден"; exit 1; }
+          root=$(mktemp -d)
+          dpkg-deb -x "$deb" "$root"
+          exe="$root/usr/bin/tglock"
+          test -f "$exe" || { echo "нет /usr/bin/tglock:"; dpkg-deb -c "$deb" | grep '/bin/'; exit 1; }
+          python3 scripts/verify_bundle_binary.py "$exe"
+
+  cli:
+    name: Headless CLI ${{ matrix.platform }}
+    needs: publish
+    strategy:
+      fail-fast: false
+      matrix:
+        include:
+          - platform: macOS universal
+            os: macos-14
+            rust-targets: aarch64-apple-darwin,x86_64-apple-darwin
+            asset: tglock-cli-universal-apple-darwin
+          - platform: Windows x64
+            os: windows-latest
+            rust-targets: x86_64-pc-windows-msvc
+            asset: tglock-cli-x86_64-pc-windows-msvc.exe
+          - platform: Linux x64
+            os: ubuntu-22.04
+            rust-targets: x86_64-unknown-linux-gnu
+            asset: tglock-cli-x86_64-unknown-linux-gnu
+
+    runs-on: ${{ matrix.os }}
 
-  release:
-    needs: build
-    runs-on: ubuntu-latest
     steps:
-      - name: Download artifacts
-        uses: actions/download-artifact@v4
+      - uses: actions/checkout@v6
 
-      - name: Create Release
-        uses: softprops/action-gh-release@v2
+      # No Node.js and no desktop libraries: the CLI must build without them.
+      - name: Install Rust
+        uses: dtolnay/rust-toolchain@stable
         with:
-          generate_release_notes: true
-          files: |
-            tglock.exe/tglock.exe
-            tglock-macos-x64/tglock-macos-x64
-            tglock-macos-arm64/tglock-macos-arm64
-            tglock-linux-x64/tglock-linux-x64
-          body: |
-            ## TGLock ${{ github.ref_name }}
+          targets: ${{ matrix.rust-targets }}
 
-            Обход блокировки Telegram через WebSocket-туннель. Один клик.
+      - name: Build (unix)
+        if: runner.os != 'Windows'
+        shell: bash
+        run: |
+          IFS=',' read -ra targets <<< "${{ matrix.rust-targets }}"
+          binaries=()
+          for target in "${targets[@]}"; do
+            cargo build --release --locked --no-default-features --features cli \
+              --bin tglock-cli --target "$target"
+            binaries+=("target/$target/release/tglock-cli")
+          done
+          if [ "${#binaries[@]}" -gt 1 ]; then
+            lipo -create -output "${{ matrix.asset }}" "${binaries[@]}"
+          else
+            cp "${binaries[0]}" "${{ matrix.asset }}"
+          fi
+          chmod +x "${{ matrix.asset }}"
+          ./"${{ matrix.asset }}" --version
 
-            | Файл | Платформа |
-            |---|---|
-            | `tglock.exe` | Windows x64 |
-            | `tglock-macos-x64` | macOS Intel |
-            | `tglock-macos-arm64` | macOS Apple Silicon |
-            | `tglock-linux-x64` | Linux x64 |
+      - name: Build (windows)
+        if: runner.os == 'Windows'
+        shell: bash
+        run: |
+          cargo build --release --locked --no-default-features --features cli \
+            --bin tglock-cli --target ${{ matrix.rust-targets }}
+          cp "target/${{ matrix.rust-targets }}/release/tglock-cli.exe" "${{ matrix.asset }}"
+          ./"${{ matrix.asset }}" --version
 
-            **[by sonic VPN](https://t.me/bysonicvpn_bot)** — полный обход блокировок для всех приложений
+      - name: Attach to the release
+        uses: softprops/action-gh-release@v2
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+        with:
+          tag_name: ${{ github.ref_name }}
+          prerelease: false
+          files: ${{ matrix.asset }}

.gitignore

@@ -1,5 +1,8 @@
 /target
+/dist
+/dist-ui
+/node_modules
+/gen
 /tools
-Cargo.lock
 *.zip
 .claude/

Cargo.toml

@@ -1,22 +1,67 @@
 [package]
 name = "tglock"
-version = "1.0.0"
+version = "2.0.0-beta.6"
 edition = "2021"
+rust-version = "1.88"
 description = "Telegram unblock via local WebSocket tunnel"
 license = "MIT"
+autobins = false
+
+[features]
+default = ["gui"]
+# The desktop GUI. Turning it off drops Tauri, the system WebView and the
+# frontend bundle from the build, which is what makes headless servers and
+# machines without a GPU or monitor able to build and run TGLock at all.
+gui = ["dep:tauri", "dep:tauri-build", "dep:open"]
+# The headless binary. Deliberately NOT in `default`.
+#
+# When both binaries exist in one build, the Tauri bundler picks the wrong one
+# as the application: `tauri build --target <triple>` packaged tglock-cli and
+# shipped it as the app in v2.0.0-beta.2 and v2.0.0-beta.3. Keeping the CLI
+# behind its own non-default feature means it simply does not exist during an
+# application build, so there is nothing to pick wrongly.
+cli = ["dep:clap", "dep:toml"]
+
+[lib]
+name = "tglock"
+path = "src/lib.rs"
+
+[[bin]]
+name = "tglock"
+path = "src/main.rs"
+required-features = ["gui"]
+
+[[bin]]
+name = "tglock-cli"
+path = "src/bin/cli.rs"
+required-features = ["cli"]
 
 [dependencies]
-eframe = "0.31"
-egui = "0.31"
-tokio = { version = "1", features = ["rt-multi-thread", "net", "io-util", "time", "macros"] }
+tauri = { version = "2", features = [], optional = true }
+open = { version = "5", optional = true }
+clap = { version = "4", features = ["derive"], optional = true }
+# Файл конфигурации CLI. TOML, а не JSON, потому что файл правят руками и в нём
+# нужны комментарии.
+toml = { version = "0.8", optional = true }
+serde = { version = "1", features = ["derive"] }
+serde_json = "1"
+tokio = { version = "1", features = [
+  "rt-multi-thread",
+  "net",
+  "io-util",
+  "time",
+  "macros",
+  "sync",
+  "signal",
+] }
 tokio-tungstenite = { version = "0.24", features = ["native-tls"] }
 native-tls = "0.2"
 futures-util = "0.3"
 aes = "0.8"
 ctr = "0.9"
 cipher = "0.4"
-open = "5"
+sha2 = "0.10"
+rand = "0.8"
 
-[[bin]]
-name = "tglock"
-path = "src/main.rs"
+[build-dependencies]
+tauri-build = { version = "2", features = [], optional = true }

HABR.md

@@ -1,86 +1,46 @@
-# Написал обход блокировки Telegram на Rust за 300 строк — без VPN, серверов и абонентки
+# TGLock v2: переписал обход Telegram с нуля — теперь работает на маке, и один прокси на всю квартиру
 
-**Простой · 6 мин · Rust · Open source · Сетевые технологии · Из песочницы**
+> **Это черновик статьи, а не документация.** Цифры в нём описывают код на
+> момент написания: «два файла, 350 строк, четыре платформы». Сейчас это 2872
+> строки Rust (из них около 1140 — тесты), семь файлов и три платформы плюс
+> headless-бинарь. Актуальное описание — [README](README.md) и
+> [docs/ARCHITECTURE_V2.md](docs/ARCHITECTURE_V2.md).
 
-**TL;DR:** Open-source приложение **TGLock** на Rust. Один клик — Telegram работает. Локальный SOCKS5-прокси заворачивает MTProto в WebSocket через `web.telegram.org`. Провайдер видит HTTPS. Windows, macOS, Linux. 300 строк кода. GitHub — [by-sonic/tglock](https://github.com/by-sonic/tglock).
+**Простой · 7 мин · Rust · Open source · macOS · Сетевые технологии**
+
+**TL;DR:** Полмесяца назад я выложил TGLock — обход блокировки Telegram через WebSocket-туннель. Статья залетела на 183K просмотров. А потом всё сломалось. Соединения рвались через 2 минуты, DC определялся неправильно, маководы плакали в комментах. Переписал с нуля. 350 строк. Работает на macOS, Windows, Linux. Один прокси — все устройства в квартире. Код: [github.com/by-sonic/tglock](https://github.com/by-sonic/tglock).
 
 ---
 
-## Почему GoodbyeDPI больше не хватает
+## Что случилось после первой статьи
 
-GoodbyeDPI, Zapret — отличные инструменты. Они фрагментируют пакеты, ломают сигнатуры DPI, и это работало. До определённого момента.
+Первая версия TGLock делала простую вещь: SOCKS5-прокси заворачивал MTProto в WebSocket через `web.telegram.org`. Провайдер видит HTTPS — Telegram работает. Концепция правильная. Реализация — нет.
 
-Проблема: провайдеры перешли от DPI к **IP-шейпингу**. Весь трафик к подсетям Telegram (149.154.x.x, 91.108.x.x) режется по скорости. Неважно, видит DPI MTProto или нет — если destination IP принадлежит Telegram, соединение троттлится.
+Через неделю после релиза прилетело:
 
-Результат: GoodbyeDPI запущен, пакеты фрагментированы, DPI обманут — а Telegram всё равно грузится 10 секунд, медиа не приходят, звонки рвутся. Пинг 200+, постоянные переподключения.
+> «Работает 2 минуты, потом Telegram пишет ошибку прокси»
 
-VPN решает, но:
-- Стоит денег
-- Гонит **весь** трафик через чужой сервер
-- Для одного Telegram — оверкилл
+> «По умолчанию выбирает неправильное сетевое подключение, вешается на VMware-адаптер»
 
-Нужен другой подход.
+> «Порт 1080 занят, как поменять?»
 
-## Идея: WebSocket через web.telegram.org
+> «А на маке будет?»
 
-Замерил: прямое TCP-соединение к серверам Telegram (149.154.167.51:443) — таймаут или 200+ мс. А вот `web.telegram.org` отвечает стабильно за 50–80 мс. Логично: это «обычный сайт», провайдер его не трогает.
+Последний вопрос задавали чаще всего. GoodbyeDPI — только Windows. Zapret — есть tpws, но это терминал и ручная настройка. GUI для обхода Telegram на маке — **не существует**. Вообще.
 
-Полез в [документацию MTProto](https://core.telegram.org/mtproto/transports):
+Решил: не патчить старый код. Переписать с нуля.
 
-> **WebSocket:** Implementation of the WebSocket transport is **pretty much the same as with TCP**... all data received and sent through WebSocket messages is to be treated as a **single duplex stream of bytes**, just like with TCP.
+## Что было не так с v1
 
-Telegram официально поддерживает WebSocket-транспорт. Эндпоинты `kws1-5.web.telegram.org` — полноценные точки входа в сеть Telegram через WSS.
+### Обрыв через 2 минуты
 
-**Схема:**
+Главный баг. WebSocket-серверы Telegram (`kws*.web.telegram.org`) шлют **Ping-фреймы** каждые ~60 секунд. Если клиент не отвечает Pong — сервер закрывает соединение.
 
-```
-Telegram Desktop → SOCKS5 → TGLock → WSS (kws{dc}.web.telegram.org) → DC
-                                ↑
-                   Провайдер видит: HTTPS к web.telegram.org
-```
+В v1 я использовал `split()` из `futures` чтобы разделить WebSocket-стрим на два потока — чтение и запись. Красиво, идиоматично, по учебнику. И сломано.
 
-Нет MTProto в трафике. Нет подозрительных IP. Обычный HTTPS.
+Ping приходит в read-поток. Pong нужно отправить через write-поток. Между ними — channel или shared state. В теории работает. На практике — Pong опаздывает на десятки миллисекунд, сервер считает клиента мёртвым.
 
-## Реализация: 300 строк на Rust
-
-Весь проект — два файла: `proxy.rs` (туннель) и `main.rs` (UI).
-
-### SOCKS5 → определение DC → WebSocket
-
-Когда Telegram Desktop подключается через SOCKS5, мы:
-
-**1.** Обрабатываем SOCKS5-хендшейк и получаем destination IP.
-
-**2.** Читаем первые 64 байта — это obfuscated2 init-пакет MTProto. Из него извлекаем настоящий DC через AES-256-CTR:
-
-```rust
-fn dc_from_init(init: &[u8; 64]) -> Option<u8> {
-    use aes::Aes256;
-    use cipher::{KeyIvInit, StreamCipher};
-
-    let mut dec = *init;
-    let mut c = ctr::Ctr128BE::<Aes256>::new(
-        init[8..40].into(),
-        init[40..56].into(),
-    );
-    c.apply_keystream(&mut dec);
-
-    let id = i32::from_le_bytes([dec[60], dec[61], dec[62], dec[63]]);
-    let dc = id.unsigned_abs() as u8;
-    (1..=5).contains(&dc).then_some(dc)
-}
-```
-
-**3.** Открываем WebSocket к нужному DC с обязательным заголовком `Sec-WebSocket-Protocol: binary` и таймаутом 10 секунд:
-
-```rust
-let (mut ws, _) = tokio::time::timeout(
-    Duration::from_secs(10),
-    tokio_tungstenite::connect_async_tls_with_config(req, None, false, Some(tls)),
-).await??;
-```
-
-**4.** Отправляем буферизованные 64 байта init-пакета как первый WebSocket-фрейм. Дальше — двунаправленный relay в одном `tokio::select!` цикле:
+**Решение в v2:** один `tokio::select!` цикл, без split. WebSocket остаётся единым объектом. `biased` приоритизирует чтение WS — Pong улетает мгновенно:
 
 ```rust
 loop {
@@ -104,72 +64,232 @@ loop {
 }
 ```
 
-Ключевой момент — **Ping/Pong**. Без ответа на Ping сервер закрывает соединение через ~2 минуты. Первая версия это игнорировала — пользователи жаловались на обрывы.
+Обратите внимание на `flush()` после каждого write в TCP. Без него tokio буферизует данные, Telegram Desktop ждёт ответ, не дожидается, переподключается. Ещё один баг v1, который маскировался под «нестабильное соединение».
 
-### Не-Telegram трафик
+### Неправильный DC
 
-Если destination IP не принадлежит Telegram — прямой TCP passthrough. Прокси не трогает ничего лишнего.
+В v1 DC определялся по IP-адресу. Таблица маппинга из документации Telegram:
 
-## Стабильность: что ломалось и как починили
+```
+149.154.160-163 → DC1
+149.154.164-167 → DC2
+91.108.56-59    → DC5
+...
+```
 
-**Проблема 1: Обрыв через 2 минуты.**
-WebSocket-сервер отправляет Ping-фреймы. Первая реализация использовала `split()` и два отдельных потока — Ping приходил в `read`-поток, а Pong нужно было отправить через `write`-поток. Решение: единый `tokio::select!` цикл без split. `biased` приоритизирует WS-чтение — Pong улетает мгновенно.
+Проблема: в подсети `149.154.164-167` живут **и DC2, и DC4**. Telegram Desktop мог коннектиться к IP, который по таблице выглядит как DC2, а на самом деле хочет DC4. Прокси открывает WebSocket к `kws2.web.telegram.org`, отправляет данные — сервер дропает соединение. Пользователь видит «прокси не настроен».
 
-**Проблема 2: Неправильный DC.**
-IP-маппинг ненадёжен: в подсети 149.154.164-167 живут и DC2, и DC4. Если отправить данные не в тот DC — сервер дропает соединение. Решение: извлекать DC из obfuscated2 init через AES-256-CTR.
+**Решение в v2:** не угадывать DC по IP. Telegram Desktop использует **obfuscated2** транспорт. Первые 64 байта — зашифрованный init-пакет. Внутри — настоящий DC ID.
 
-**Проблема 3: Зависание на подключении.**
-Если `kws*.web.telegram.org` не отвечает — прокси висел бесконечно. Решение: `tokio::time::timeout(10s)` на WebSocket connect.
+Ключ: байты `[8..40]`, IV: `[40..56]`. Алгоритм: AES-256-CTR. DC ID: `i32` в байтах `[60..64]` расшифрованного пакета.
 
-**Проблема 4: Потеря данных.**
-TCP-write без `flush()` мог буферизовать данные. Telegram Desktop ожидал ответ, не получал его, переподключался. Решение: явный `flush()` после каждого write.
+```rust
+fn dc_from_init(init: &[u8; 64]) -> Option<u8> {
+    use aes::Aes256;
+    use cipher::{KeyIvInit, StreamCipher};
 
-## UI: egui, не Electron
+    let mut dec = *init;
+    let mut c = ctr::Ctr128BE::<Aes256>::new(
+        init[8..40].into(),
+        init[40..56].into(),
+    );
+    c.apply_keystream(&mut dec);
 
-Нативный GUI через egui. Тёмная тема, минимальный интерфейс. Бинарник ~6 МБ, без зависимостей.
+    let id = i32::from_le_bytes([dec[60], dec[61], dec[62], dec[63]]);
+    let dc = id.unsigned_abs() as u8;
+    (1..=5).contains(&dc).then_some(dc)
+}
+```
 
-Одна кнопка — ПОДКЛЮЧИТЬ/ОТКЛЮЧИТЬ. Статистика в реальном времени: активные соединения, WebSocket-туннели, текущий DC, аптайм.
+12 строк. Три крейта (`aes`, `ctr`, `cipher`). Зато DC определяется **точно**, а не «скорее всего».
 
-## Кроссплатформенность
+IP-маппинг остался как fallback — на случай если init-пакет повреждён (что на практике не случается).
 
-Ни одной строки платформо-специфичного кода. Работает на:
-- **Windows** x64
-- **macOS** Intel + Apple Silicon
-- **Linux** x64
+### Привязка к Windows
 
-CI/CD через GitHub Actions — при создании тега автоматически собираются бинарники для всех платформ.
+v1 использовала:
+- `netsh` для смены DNS
+- Хардкоженный путь к шрифтам Windows
+- `taskkill` для остановки процессов
+- `ipconfig /flushdns`
 
-## Сравнение
+Ни одна из этих вещей не нужна для WebSocket-прокси. DNS менять не надо — `web.telegram.org` резолвится нормально. Новый интерфейс работает в нативной оболочке Tauri 2 и использует системную типографику. Весь старый платформо-специфичный код был мусором.
 
-| | GoodbyeDPI | Zapret | VPN | **TGLock** |
+**v2: 0 строк платформо-специфичного кода.** Один и тот же бинарник компилируется на Windows, macOS и Linux без единого `#[cfg(target_os)]`.
+
+## macOS: почему это важно
+
+Среди разработчиков, дизайнеров, людей из IT — процент маководов огромный. А инструментов для обхода блокировки Telegram на маке — ноль целых, ноль десятых.
+
+- **GoodbyeDPI** — Windows only. Даже не обсуждается.
+- **Zapret** — есть `tpws` для macOS, но это CLI. Нужно: `brew install`, `sudo`, правка конфигов, ручная настройка системного прокси через `networksetup`. Для техничных людей — ОК. Для остальных — нет.
+- **VPN** — работает, но гонит весь трафик. Для одного Telegram — оверкилл за $5/мес.
+
+TGLock v2: скачал бинарник, запустил, нажал кнопку. Всё. Никакого `brew`, никакого `sudo`, никаких конфигов.
+
+Для macOS собирается единое universal-приложение: один пакет работает и на Apple Silicon, и на Intel. Сборка выполняется автоматически в GitHub Actions.
+
+### Gatekeeper
+
+Apple блокирует неподписанные приложения. Developer ID стоит $99/год. Для бесплатного open-source — не вариант. Решение стандартное:
+
+```bash
+xattr -cr ~/Downloads/tglock-macos-arm64
+chmod +x ~/Downloads/tglock-macos-arm64
+```
+
+Две команды, один раз.
+
+## LAN-режим: один прокси на всю квартиру
+
+Это была самая частая просьба в ишью:
+
+> «Цель: пустить все домашние устройства с Telegram через один такой прокси на компе в локальной сети»
+
+В v1 прокси слушал `127.0.0.1:1080` — только локально. Устройства в сети не могли подключиться.
+
+В v2 — чекбокс **LAN** в интерфейсе. Включаешь — прокси биндится на `0.0.0.0`. Все устройства в домашней сети могут использовать прокси.
+
+```
+Телефон  ──┐
+Планшет ───┤── SOCKS5 → 192.168.1.42:1080 ──► TGLock ──► WSS → DC
+Ноутбук ───┘
+```
+
+Приложение автоматически определяет LAN IP и показывает его в интерфейсе. На телефоне в настройках Telegram: SOCKS5, адрес — IP компьютера, порт — тот что в приложении.
+
+Один компьютер. Все устройства. Без VPN, без роутера, без конфигов.
+
+### Настраиваемый порт
+
+Ещё один ишью: «порт 1080 занят другим сервисом».
+
+Теперь порт можно менять прямо в интерфейсе. По умолчанию 1080, но если занят — ставишь любой другой. Порт валидируется при старте, в настройках Telegram автоматически отображается текущий.
+
+## Архитектура v2
+
+Два файла. 350 строк. Всё.
+
+### proxy.rs (~160 строк)
+
+```
+TcpListener (0.0.0.0 | 127.0.0.1 : port)
+      │
+      ▼
+  SOCKS5 handshake
+      │
+      ├── IP ∈ Telegram? ──► read 64-byte init
+      │                       │
+      │                       ▼
+      │                  dc_from_init (AES-256-CTR)
+      │                       │
+      │                       ▼
+      │                  WSS kws{dc}.web.telegram.org
+      │                       │
+      │                       ▼
+      │                  select! { ws ⟷ tcp }
+      │
+      └── IP ∉ Telegram? ──► direct TCP relay
+```
+
+Никаких абстракций, traits, generics. Прямолинейный async-код. Каждое соединение — один `tokio::spawn`, один `select!` цикл.
+
+### main.rs (~190 строк)
+
+GUI на Tauri 2 с TypeScript-интерфейсом. Настройки и диагностика открываются как внутренние страницы одного окна; статистика в реальном времени показывает активные соединения, WS-туннели, текущий DC и аптайм.
+
+Кнопка «Настроить автоматически» — открывает Telegram через `tg://socks?server=...&port=...`. Один клик до рабочего Telegram.
+
+## CI/CD: бинарники для всех
+
+GitHub Actions при пуше тега `v*` собирает:
+
+| Файл | Платформа |
+|---|---|
+| `tglock.exe` | Windows x64 |
+| `tglock-macos-arm64` | macOS Apple Silicon |
+| `tglock-macos-x64` | macOS Intel |
+| `tglock-linux-x64` | Linux x64 |
+
+Четыре платформы, один workflow, автоматические релизы. Скачал — запустил — работает.
+
+```yaml
+strategy:
+  matrix:
+    include:
+      - os: windows-latest
+        target: x86_64-pc-windows-msvc
+        artifact: tglock.exe
+      - os: macos-latest
+        target: aarch64-apple-darwin
+        artifact: tglock-macos-arm64
+      - os: macos-latest
+        target: x86_64-apple-darwin
+        artifact: tglock-macos-x64
+      - os: ubuntu-latest
+        target: x86_64-unknown-linux-gnu
+        artifact: tglock-linux-x64
+```
+
+## Что изменилось: v1 vs v2
+
+| | v1 | v2 |
+|---|---|---|
+| DC detection | IP-маппинг (ненадёжен) | AES-256-CTR из init (точно) |
+| Ping/Pong | Игнорировался → обрыв через 2 мин | `biased` select → мгновенный Pong |
+| flush() | Нет → потеря данных | Явный flush после каждого write |
+| WS timeout | Нет → бесконечное зависание | 10 секунд |
+| Платформы | Windows | Windows, macOS, Linux |
+| DNS | Менял системный DNS | Не трогает |
+| Адаптеры | Определял сетевой адаптер (баг с VMware) | Не определяет, не нужно |
+| Порт | Хардкод 1080 | Настраиваемый |
+| LAN | Нет | Чекбокс, 0.0.0.0 |
+| Файлов | 4 модуля + bat-скрипт | 2 файла |
+| Строк | ~800 | ~350 |
+
+Половину кода удалил. Стало стабильнее.
+
+## Сравнение с альтернативами (2026)
+
+| | GoodbyeDPI | Zapret | VPN | **TGLock v2** |
 |---|---|---|---|---|
-| Метод | Фрагментация | Desync | Туннель | WebSocket |
-| Обходит IP-шейпинг | Нет | Нет | Да | **Да** |
+| Подход | Фрагментация | Desync | Туннель | WebSocket |
+| IP-шейпинг | Не обходит | Не обходит | Обходит | **Обходит** |
+| macOS | Нет | CLI | Да | **GUI** |
 | Нужен сервер | Нет | Нет | Да | **Нет** |
 | Весь трафик | Нет | Нет | Да | **Только Telegram** |
-| Кроссплатформа | Windows | Win/Mac/Linux | Да | **Win/Mac/Linux** |
-| Размер | ~1 МБ | ~2 МБ | Зависит | **~6 МБ** |
+| LAN-шаринг | Нет | Можно настроить | Да | **Чекбокс** |
+| Стоимость | 0₽ | 0₽ | $3–10/мес | **0₽** |
 
-## Цифры
+## Цифры v2
 
-- **300** строк кода (proxy + UI)
-- **2** файла (`proxy.rs` + `main.rs`)
-- **3** платформы (Windows, macOS, Linux)
+- **350** строк кода
+- **2** файла
+- **4** платформы (Win x64, macOS ARM64, macOS x64, Linux x64)
+- **0** строк платформо-специфичного кода
 - **0** серверов
 - **0₽**
 
 ## Скачать
 
-**[github.com/by-sonic/tglock](https://github.com/by-sonic/tglock)** → Releases
+**[github.com/by-sonic/tglock](https://github.com/by-sonic/tglock)** → [Releases](https://github.com/by-sonic/tglock/releases/latest)
 
-Или собрать: `git clone ... && cargo build --release`
+Или собрать:
 
-**P.S.** Для полного обхода блокировок (YouTube, Discord, Instagram) — **[by sonic VPN](https://t.me/bysonicvpn_bot)**.
+```bash
+git clone https://github.com/by-sonic/tglock.git
+cd tglock
+cargo build --release
+```
+
+macOS: после скачивания `xattr -cr tglock-macos-arm64 && chmod +x tglock-macos-arm64`
+
+**P.S.** Для полного обхода блокировок (YouTube, Discord, Instagram и всё остальное) — **[RoseVPN](https://t.me/rosevpnru_bot)**.
 
 ---
 
 *by sonic*
 
-**Теги:** telegram, rust, websocket, socks5, mtproto, dpi, обход блокировок, open-source
+**Теги:** telegram, rust, websocket, macos, socks5, mtproto, обход блокировок, open-source, кроссплатформенность
 
-**Хабы:** Rust · Open source · Сетевые технологии
+**Хабы:** Rust · Open source · macOS · Сетевые технологии

README.md

@@ -1,80 +1,509 @@
+<!-- ════════════════════════ ROSEVPN — sponsor ════════════════════════ -->
+
 <p align="center">
-  <h1 align="center">TGLock</h1>
-  <p align="center"><b>Обход блокировки Telegram через WebSocket-туннель</b></p>
-  <p align="center">Без VPN. Без серверов. Без абонентки. Один клик.</p>
-  <p align="center">
-    <a href="https://github.com/by-sonic/tglock/releases/latest"><img src="https://img.shields.io/github/v/release/by-sonic/tglock?style=flat-square&color=blue" alt="Release"></a>
-    <img src="https://img.shields.io/badge/platform-Windows%20%7C%20macOS%20%7C%20Linux-333?style=flat-square" alt="Platform">
-    <img src="https://img.shields.io/badge/rust-stable-orange?style=flat-square&logo=rust" alt="Rust">
-    <a href="LICENSE"><img src="https://img.shields.io/github/license/by-sonic/tglock?style=flat-square" alt="MIT"></a>
-  </p>
+  <a href="https://t.me/rosevpnru_bot">
+    <img src="https://img.shields.io/badge/%F0%9F%8C%B9%20RoseVPN-%D0%9F%D0%BE%D0%BF%D1%80%D0%BE%D0%B1%D0%BE%D0%B2%D0%B0%D1%82%D1%8C%20%D0%B1%D0%B5%D1%81%D0%BF%D0%BB%D0%B0%D1%82%D0%BD%D0%BE-E63946?style=for-the-badge&logo=telegram&logoColor=white&labelColor=0a0a0a" height="44" alt="RoseVPN — попробовать бесплатно в Telegram"/>
+  </a>
+</p>
+
+<p align="center">
+  <b>Быстрый VPN для России</b> — YouTube без буферизации, Discord/Instagram/ChatGPT снова работают.<br/>
+  <sub>Подключение в Telegram через <a href="https://t.me/rosevpnru_bot"><b>@rosevpnru_bot</b></a> — бесплатный пробный период, без регистрации, без карты.</sub>
+</p>
+
+<p align="center">
+  <a href="https://t.me/rosevpnru_bot"><img alt="YouTube — без буферов" src="https://img.shields.io/badge/YouTube-%D0%B1%D0%B5%D0%B7%20%D0%B1%D1%83%D1%84%D0%B5%D1%80%D0%BE%D0%B2-E63946?style=flat-square&logo=youtube&logoColor=white"></a>
+  <a href="https://t.me/rosevpnru_bot"><img alt="Discord — голос работает" src="https://img.shields.io/badge/Discord-%D0%B3%D0%BE%D0%BB%D0%BE%D1%81%20%D1%80%D0%B0%D0%B1%D0%BE%D1%82%D0%B0%D0%B5%D1%82-E63946?style=flat-square&logo=discord&logoColor=white"></a>
+  <a href="https://t.me/rosevpnru_bot"><img alt="Instagram — открывается" src="https://img.shields.io/badge/Instagram-%D0%BE%D1%82%D0%BA%D1%80%D1%8B%D0%B2%D0%B0%D0%B5%D1%82%D1%81%D1%8F-E63946?style=flat-square&logo=instagram&logoColor=white"></a>
+  <a href="https://t.me/rosevpnru_bot"><img alt="ChatGPT — доступен" src="https://img.shields.io/badge/ChatGPT-%D0%B4%D0%BE%D1%81%D1%82%D1%83%D0%BF%D0%B5%D0%BD-E63946?style=flat-square&logo=openai&logoColor=white"></a>
 </p>
 
 ---
 
-## Скачать
+<!-- ═════════════════════════════ TGLOCK ═════════════════════════════ -->
 
-**[Последний релиз](https://github.com/by-sonic/tglock/releases/latest)**
+<div align="center">
 
-| Файл | Платформа |
+# 🔓 TGLock
+
+### Обход блокировки Telegram через WebSocket-туннель
+
+**Один клик. Без VPN. Без серверов. Без подписки.**
+
+<p>
+  <a href="https://github.com/by-sonic/tglock/releases/latest"><img alt="Скачать последний релиз" src="https://img.shields.io/github/v/release/by-sonic/tglock?style=for-the-badge&color=2ea043&label=%D1%81%D0%BA%D0%B0%D1%87%D0%B0%D1%82%D1%8C"></a>
+  <a href="https://github.com/by-sonic/tglock/releases"><img alt="Всего загрузок" src="https://img.shields.io/github/downloads/by-sonic/tglock/total?style=for-the-badge&color=0969da&label=%D0%B7%D0%B0%D0%B3%D1%80%D1%83%D0%B7%D0%BE%D0%BA"></a>
+  <a href="https://github.com/by-sonic/tglock/stargazers"><img alt="GitHub stars" src="https://img.shields.io/github/stars/by-sonic/tglock?style=for-the-badge&color=f5a623"></a>
+</p>
+
+<p>
+  <img alt="Windows" src="https://img.shields.io/badge/Windows-0078D6?style=flat&logo=windows&logoColor=white">
+  <img alt="macOS" src="https://img.shields.io/badge/macOS-000000?style=flat&logo=apple&logoColor=white">
+  <img alt="Linux" src="https://img.shields.io/badge/Linux-FCC624?style=flat&logo=linux&logoColor=black">
+  <img alt="Rust" src="https://img.shields.io/badge/Rust-CE422B?style=flat&logo=rust&logoColor=white">
+  <a href="LICENSE"><img alt="MIT License" src="https://img.shields.io/github/license/by-sonic/tglock?style=flat&color=lightgrey"></a>
+</p>
+
+</div>
+
+> **Telegram стал тормозить или перестал открываться?** Запусти TGLock — и мессенджер снова работает. Не нужны VPN, прокси-серверы, абонентская плата или регистрация.
+
+<p align="center">
+  <img src="docs/assets/tglock-v2-main.jpeg" width="420" alt="Новый интерфейс TGLock"/>
+</p>
+
+---
+
+## 🤔 Что это и зачем
+
+TGLock — это **локальный прокси** на твоём компьютере: принимает и MTProto, и SOCKS5. Он перехватывает соединения Telegram, заворачивает их в WebSocket и отправляет на веб-инфраструктуру Telegram — по нескольким маршрутам сразу, переключаясь на следующий, если текущий перестал отвечать. Провайдер видит обычный HTTPS.
+
+**Кому подойдёт:**
+
+- 📱 Telegram открывается через раз, сообщения уходят с задержкой, фото и видео не грузятся
+- 🛡 GoodbyeDPI, Zapret или ByeDPI больше не помогают — провайдер шейпит **по IP**
+- 🍎 Нужен графический интерфейс под **macOS**
+- 💻 Нужно решение для **Windows, macOS или Linux** без подписок и без своего сервера
+- 🖥 Нужен вариант **для сервера или машины без монитора** — для этого есть [`tglock-cli`](#-без-графического-интерфейса-tglock-cli)
+
+**Чего TGLock не делает** — честно, чтобы не тратить твоё время:
+
+- ❌ **Голосовые и видеозвонки.** Они идут по UDP, а TGLock проксирует только TCP. Со звонками ничего не изменится
+- ❌ **Всё, кроме Telegram.** YouTube, Discord, Instagram, ChatGPT работать не начнут: TGLock разворачивает только MTProto — протокол, который больше нигде не используется
+- ❌ **Android и iOS.** Своего приложения нет. Телефон можно подключить к TGLock на компьютере через [LAN-режим](#-lan-режим--один-прокси-на-всю-квартиру)
+
+**Чем отличается от VPN:** TGLock работает **только с Telegram**. Остальной трафик идёт напрямую — ничего не замедляется, мобильный трафик не расходуется впустую.
+
+---
+
+## ⚡ Скачать
+
+**[👉 Последний релиз](https://github.com/by-sonic/tglock/releases/latest)**
+
+| Платформа | Файл |
 |---|---|
-| `tglock.exe` | Windows x64 |
-| `tglock-macos-arm64` | macOS Apple Silicon (M1–M4) |
-| `tglock-macos-x64` | macOS Intel |
-| `tglock-linux-x64` | Linux x64 |
+| **Windows 10/11** (x64) | `_x64-setup.exe` |
+| **macOS** (Apple Silicon + Intel) | universal `.dmg` |
+| **Linux** (x86_64) | `.deb` |
+| **Linux** (x86_64, портативно) | `.AppImage` |
+| **Сервер, контейнер, машина без монитора** | `tglock-cli-*` |
 
-## Как пользоваться
+Все сборки весят единицы мегабайт. Исключение — `.AppImage`: он несёт своё окружение и поэтому крупный.
 
-1. Скачай и запусти
-2. Нажми **ПОДКЛЮЧИТЬ**
-3. Нажми **Настроить автоматически** → в Telegram нажми «Подключить»
-4. Готово
+> **🖥 `tglock-cli`** — тот же туннель без графического интерфейса, одним бинарём. Нужен там, где окно не создаётся: сервер, контейнер, виртуалка, машина без монитора. Доступен начиная с `v2.0.0-beta.2`. Если ты скачал beta.2 и приложение не открывалось — это была ошибка сборки, исправлено в beta.3. Подробности — [ниже](#-без-графического-интерфейса-tglock-cli).
 
-Ручная настройка: Telegram → Настройки → Продвинутые → Тип соединения → SOCKS5 → `127.0.0.1:1080`
+### 🛡 Антивирус ругается, SmartScreen предупреждает, VirusTotal показывает детекты
 
-## Как это работает
+Так и будет. Объясню механизм и дам способы проверить, не доверяя мне на слово.
 
-```
-Telegram Desktop → SOCKS5 (127.0.0.1:1080) → TGLock → WSS (web.telegram.org) → DC
+**Что ты увидишь.** На Windows — «Система Windows защитила ваш компьютер» от SmartScreen. На VirusTotal — детекты у части движков, обычно единицы из примерно шестидесяти.
+
+**Почему.** Складываются две вещи. Установщик не подписан сертификатом, а неподписанные файлы проверяются эвристиками гораздо строже, чем подписанные. И само поведение программы — открыть локальный порт, объявить себя прокси-сервером, прописаться в настройки соединения Telegram — это ровно тот профиль, по которому эвристики ищут прокси-трояны. Программа делает именно это, только по твоей просьбе. Отличить одно от другого автоматически движок не может, поэтому и реагирует.
+
+**Подписи не будет.** Сертификат — это ежегодный платёж, а проект бесплатный и ничего не зарабатывает. Значит предупреждение останется, и делать вид, что «скоро подпишем», я не буду.
+
+**Как проверить вместо доверия.** Три способа, все не требуют верить мне:
+
+1. **Сверить контрольную сумму.** GitHub публикует `sha256` каждого файла прямо на [странице релиза](https://github.com/by-sonic/tglock/releases/latest) — разверни `Assets` и увидишь digest рядом с именем. Сравни с тем, что скачалось:
+
+   ```powershell
+   Get-FileHash .\TGLock_<версия>_x64-setup.exe -Algorithm SHA256
+   ```
+
+   ```bash
+   sha256sum tglock-cli-x86_64-unknown-linux-gnu   # Linux
+   shasum -a 256 tglock-cli-universal-apple-darwin  # macOS
+   ```
+
+   Это доказывает, что файл не подменили по пути к тебе.
+
+2. **Посмотреть, как файл собирался.** Бинарники собирает GitHub Actions из публичного коммита, лог открыт и его никто не может отредактировать задним числом. У каждого релиза на странице Actions есть свой запуск: видно, какой коммит взят и какими командами собран. Ссылка на него — в описании релиза.
+
+3. **Собрать самому.** Для CLI это одна команда и никаких зависимостей кроме Rust:
+
+   ```bash
+   cargo build --release --locked --no-default-features --features cli --bin tglock-cli
+   ```
+
+   Полная сборка с интерфейсом — [ниже](#-сборка-из-исходников).
+
+**Если этого недостаточно — не запускай.** Это нормальное решение, а не паранойя: исполняемый файл из интернета без подписи заслуживает недоверия по умолчанию. Собери из исходников или возьми [tg-ws-proxy](https://github.com/Flowseal/tg-ws-proxy) — он решает ту же задачу и тоже открыт.
+
+> **🍎 macOS:** пока сборка не нотарифицирована Apple, при первом запуске может понадобиться:
+> ```bash
+> xattr -cr /Applications/TGLock.app
+> ```
+> Это снимает карантин Gatekeeper с приложения, скачанного из GitHub.
+
+---
+
+## 🚀 Как пользоваться
+
+1. **Скачай и запусти** приложение для своей системы.
+2. Нажми **«Включить защиту»**.
+3. TGLock откроет Telegram и предложит подключить локальный MTProto-прокси.
+4. ✅ **Telegram работает.** Окно TGLock можно свернуть.
+
+### Ручная настройка (если автоматическая не сработала)
+
+Telegram → Настройки → **Продвинутые** → Тип соединения → **Использовать прокси** → **SOCKS5**
+
+- Сервер: `127.0.0.1`
+- Порт: `1080`
+
+### 🏠 LAN-режим — один прокси на всю квартиру
+
+В окне TGLock включи галочку **LAN** — приложение начнёт слушать на `0.0.0.0`. Все устройства в домашней сети (телефон, планшет, ноутбук, телевизор) смогут подключиться к `<IP-компьютера>:1080` и тоже получить рабочий Telegram.
+
+Ссылку `tg://proxy` с уже подставленным адресом TGLock открывает сам при включении — её достаточно переслать себе в Telegram и открыть на телефоне. Если нужен адрес руками: `ipconfig` на Windows, `ip a` на Linux, `ifconfig` на macOS.
+
+Удобно, если дома один компьютер всегда включён — он становится «домашним Telegram-роутером».
+
+В LAN-режиме TGLock пропускает **только адреса Telegram**. Открытым SOCKS5-прокси для всего интернета он при этом не становится — иначе им бы воспользовались не только твои устройства.
+
+### 🖥 Без графического интерфейса: `tglock-cli`
+
+Для сервера, виртуалки, контейнера и машины без монитора или без 3D-ускорения. Это отдельный бинарь, в котором **нет ни Tauri, ни системного WebView** — там, где окно просто не создаётся, CLI работает.
+
+```bash
+tglock-cli                                # 127.0.0.1:1080, только для этого компьютера
+tglock-cli --lan                           # 0.0.0.0:1080, только адреса Telegram
+tglock-cli --bind 10.0.0.5 --port 1443     # свой адрес и порт
+tglock-cli --worker my-name.workers.dev    # резервный маршрут, см. docs/CLOUDFLARE_WORKER.md
+tglock-cli --help                          # все флаги
 ```
 
-1. Локальный SOCKS5-прокси перехватывает соединения Telegram
-2. Из MTProto init-пакета извлекается номер DC (AES-256-CTR)
-3. Трафик заворачивается в WebSocket через `kws{dc}.web.telegram.org`
-4. Провайдер видит обычный HTTPS к `web.telegram.org`
-5. Остальной трафик проходит напрямую
+#### Файл настроек
 
-## Почему не GoodbyeDPI / Zapret?
+Чтобы не собирать батник с ключами при каждом запуске ([#32](https://github.com/by-sonic/tglock/issues/32)), положите рядом с бинарём `tglock.toml` — он подхватится сам. Или укажите путь: `tglock-cli --config /etc/tglock.toml`.
 
-GoodbyeDPI и Zapret фрагментируют пакеты чтобы обмануть DPI. Но если провайдер **шейпит по IP** — они бесполезны.
+```toml
+port = 1080
+lan = true
 
-TGLock маскирует трафик под обычный HTTPS. DPI не видит MTProto. IP-шейпинг не работает — `web.telegram.org` не блокируется.
+# Секрет — вторая половина ссылки tg://proxy. Для сервиса его нужно закрепить,
+# иначе после перезапуска все настроенные клиенты отвалятся. Запустите один
+# раз, скопируйте из напечатанной ссылки и вставьте сюда.
+secret = "dd00112233445566778899aabbccddeeff"
 
-## Стек
+worker = ["my-name.workers.dev"]
+```
 
-| | |
+Полный пример со всеми полями и пояснениями — [`tglock.example.toml`](tglock.example.toml).
+
+Приоритеты: значения по умолчанию → файл → флаги. Флаг всегда сильнее файла. Флаги-переключатели (`--lan`, `--allow-direct`, `--quiet`) могут только включать: их отсутствие означает «взять из файла», а не «выключить».
+
+Опечатка в файле — ошибка при старте с перечислением допустимых полей, а не молча проигнорированная строка. Сервис, который из-за `porrt = 1443` слушает 1080, хуже сервиса, который не запустился.
+
+Файл с секретом внутри держите с правами `600`: это доступ к вашему прокси.
+
+При запуске печатается готовая `tg://proxy`-ссылка — её можно открыть на любом устройстве в сети, чтобы Telegram настроился сам. Дальше в лог идёт по строке на каждое изменение состояния: сколько соединений, какой дата-центр, какой маршрут живой, сколько сбоев.
+
+Прав администратора не нужно: TGLock не правит ни системный DNS, ни файл `hosts` — нужные адреса Telegram зашиты в маршрутах, а TLS SNI остаётся настоящим.
+
+`--lan` и любой другой сетевой адрес пропускают **только** адреса Telegram. Обычным SOCKS5-прокси TGLock становится исключительно по явному `--allow-direct`, и на сетевом адресе это открытый прокси для всего интернета — включайте осознанно.
+
+#### Юнит для systemd
+
+```ini
+[Unit]
+Description=TGLock — Telegram через WebSocket-туннель
+After=network-online.target
+Wants=network-online.target
+
+[Service]
+Type=exec
+ExecStart=/usr/local/bin/tglock-cli --config /etc/tglock.toml
+Restart=on-failure
+RestartSec=5s
+StateDirectory=tglock
+DynamicUser=yes
+NoNewPrivileges=yes
+ProtectSystem=strict
+ProtectHome=yes
+PrivateTmp=yes
+RestrictAddressFamilies=AF_INET AF_INET6
+
+[Install]
+WantedBy=multi-user.target
+```
+
+```bash
+sudo install -m755 tglock-cli-x86_64-unknown-linux-gnu /usr/local/bin/tglock-cli
+sudo install -m600 tglock.example.toml /etc/tglock.toml   # и отредактировать
+sudo systemctl enable --now tglock
+journalctl -u tglock -f
+```
+
+**Закреплённый секрет здесь обязателен**, и это не украшение: секрет — половина `tg://proxy`-ссылки. Без него он генерируется заново при каждом старте, и после первого же `systemctl restart` все настроенные клиенты перестанут подключаться. Задайте `secret` в `/etc/tglock.toml` (файл с правами `600`) либо `secret_file = "/var/lib/tglock/secret"` — тогда `StateDirectory=tglock` создаст каталог с нужными правами, а файл запишется с режимом `600`.
+
+При старте без закреплённого секрета CLI печатает предупреждение — молча уйти в такое состояние он не даст.
+
+Остановка по `systemctl stop` приходит как `SIGTERM` — CLI закрывает туннели и выходит с нулевым кодом, а не умирает по `SIGKILL`.
+
+#### Docker
+
+```dockerfile
+FROM rust:1.88 AS build
+WORKDIR /src
+COPY . .
+RUN cargo build --release --locked --no-default-features --features cli --bin tglock-cli
+
+FROM debian:bookworm-slim
+RUN apt-get update && apt-get install -y --no-install-recommends ca-certificates \
+    && rm -rf /var/lib/apt/lists/*
+COPY --from=build /src/target/release/tglock-cli /usr/local/bin/tglock-cli
+EXPOSE 1080
+ENTRYPOINT ["tglock-cli", "--lan", "--secret-file", "/data/secret"]
+```
+
+```bash
+docker run -d --name tglock -p 1080:1080 -v tglock-data:/data tglock
+```
+
+Образу не нужны ни Node.js, ни `libwebkit2gtk` — только `ca-certificates` для проверки сертификата Telegram.
+
+---
+
+## 🔬 Как это работает
+
+```
+Telegram Desktop / mobile (через LAN)
+              ▼
+   MTProto или SOCKS5 (127.0.0.1:1080 либо 0.0.0.0:1080)
+              ▼
+        TGLock — читает первые 64 байта
+                 obfuscated2 init-пакета,
+                 расшифровывает AES-256-CTR,
+                 достаёт номер DC
+              ▼
+   WSS → kws{dc}.web.telegram.org
+         каскад маршрутов, см. ниже
+              ▼
+        Telegram Data Center
+```
+
+1. **Локальный прокси** принимает соединения Telegram: и MTProto (по ссылке `tg://proxy`), и SOCKS5.
+2. Из первых 64 байт `obfuscated2`-пакета **расшифровывается номер DC** — AES-256-CTR, ключ в байтах `[8..40]`, IV в `[40..56]`, индекс DC — `i16` в `[60..62]`. Отрицательное значение означает медиа-соединение.
+3. Трафик заворачивается в **WebSocket** к `kws{dc}.web.telegram.org` — это тот же домен, через который работает Telegram Web в браузере.
+4. **Маршрут выбирается каскадом**, и это главное отличие 2.0 от первой версии. Один домен может резолвиться в недоступный адрес, поэтому по очереди пробуются: закреплённые IP Telegram, их дублёры `kwsN-1`, системный DNS и — если ты его настроил — твой собственный Cloudflare Worker. Упавший маршрут уходит в cooldown с удвоением задержки, удачный запоминается для этого DC. Системный DNS и файл `hosts` при этом **не изменяются**: TCP-соединение идёт на закреплённый IP, а TLS SNI и заголовок `Host` остаются настоящими, поэтому сертификат Telegram проверяется как обычно.
+5. Провайдер видит **TLS-handshake к `web.telegram.org`** — легитимный HTTPS, MTProto в нём не виден.
+6. Весь остальной трафик (не-Telegram) проходит **напрямую** — без замедления.
+
+> Интерфейс различает три состояния и не выдаёт одно за другое: **«Защита включена»** — локальный порт открыт, туннеля пока нет; **«Ищем новый маршрут»** — попытки были неудачными, идёт перебор; **«Telegram на связи»** — есть установленный туннель, то есть WebSocket-рукопожатие уже прошло. Смешивание первого и третьего состояния и было основной причиной жалоб «прокси подключён, а Telegram не работает».
+
+📖 **Архитектура 2.0, различение протоколов и честный список ограничений** — [docs/ARCHITECTURE_V2.md](docs/ARCHITECTURE_V2.md). Запасной маршрут через свой Cloudflare Worker, со скриптом и пошаговой установкой — [docs/CLOUDFLARE_WORKER.md](docs/CLOUDFLARE_WORKER.md). Разбор всех issue и того, что в них было обещано зря — [docs/ISSUE_AUDIT.md](docs/ISSUE_AUDIT.md). Черновик статьи про переход v1 → v2 лежит в [HABR.md](HABR.md) — цифры там описывают код на момент написания, документацией он не является.
+
+---
+
+## 🆚 Сравнение с альтернативами
+
+| | GoodbyeDPI | Zapret | AmneziaVPN | **TGLock** |
+|---|:---:|:---:|:---:|:---:|
+| Подход | Фрагментация пакетов | TCP/UDP desync | Полноценный VPN-туннель | **WebSocket-туннель** |
+| Обходит IP-шейпинг | ❌ | ❌ | ✅ | **✅** |
+| macOS (GUI) | ❌ Windows only | ❌ только CLI | ✅ | **✅** |
+| Нужен сервер / подписка | ❌ | ❌ | ✅ ($) | **❌** |
+| Только Telegram | ❌ | ❌ | ❌ | **✅** |
+| LAN-шаринг | ❌ | сложно | ✅ | **✅ (галочка)** |
+| Режим без GUI | ✅ | ✅ | ❌ | **✅ (`tglock-cli`)** |
+| Размер | ~200 КБ | ~5 МБ | ~80 МБ | **2 МБ установщик, 2 МБ CLI** |
+| Цена | 0 ₽ | 0 ₽ | свой сервер | **0 ₽** |
+
+> **⚠ Когда TGLock не подойдёт:** если заблокирован не только Telegram, а ещё YouTube, Discord, Instagram или ChatGPT — обходить каждый сервис отдельно смысла нет, нужен полноценный VPN. TGLock эту задачу не решает и решать не будет: он разворачивает только MTProto.
+>
+> Звонки тоже не заработают — они по UDP, а TGLock проксирует только TCP.
+
+---
+
+## ❓ Часто задаваемые вопросы
+
+<details>
+<summary><b>Telegram заблокировали в России — это правда?</b></summary>
+
+Полностью Telegram в РФ не заблокирован, но провайдеры **замедляют** трафик через DPI и **шейпят по IP-диапазонам** Telegram DC (149.154.160–175, 91.108.4–8, 91.108.56–59 и др.). У части пользователей мессенджер открывается через раз, видео не грузится, фото уходят минутами.
+
+TGLock решает именно это — заворачивает Telegram-трафик в HTTPS к веб-инфраструктуре Telegram, которая под шейпинг не попадает. **Голосовые и видеозвонки он не лечит:** они идут по UDP, а TGLock проксирует только TCP.
+</details>
+
+<details>
+<summary><b>Это безопасно? Что с моими данными?</b></summary>
+
+TGLock — **локальный прокси**. Он работает только на твоём компьютере и не отправляет данные третьим сторонам. Соединение идёт к серверам Telegram через их же домен `web.telegram.org` — тот же, что использует Telegram Web в браузере. Единственное исключение — если ты сам укажешь в настройках свой Cloudflare Worker как резервный маршрут; по умолчанию это поле пустое, и никакой сторонней инфраструктуры в схеме нет.
+
+Кода — около 2900 строк Rust (из них ~1100 приходится на тесты) и ~380 строк TypeScript на интерфейс. Всё открыто, можно прочитать и собрать самому. Бинарники в релизах собираются из этого же исходника в GitHub Actions — логи сборки публичные.
+</details>
+
+<details>
+<summary><b>Чем отличается от GoodbyeDPI / Zapret / ByeDPI?</b></summary>
+
+GoodbyeDPI, Zapret и ByeDPI **фрагментируют пакеты**, чтобы DPI не распознал MTProto. Это работает, пока провайдер блокирует *по содержимому*. Но если шейпинг идёт **по IP** (а так делают большинство крупных РФ-провайдеров с 2024–2026 — Ростелеком, МТС, Билайн, Мегафон), фрагментация не помогает: пакеты всё равно идут на «нехороший» IP и троттлятся.
+
+TGLock же отправляет трафик на **`web.telegram.org`** — обычный HTTPS-домен, который под IP-шейпинг Telegram DC не попадает.
+</details>
+
+<details>
+<summary><b>Работает ли на iPhone или Android?</b></summary>
+
+Своего приложения под Android и iOS нет — TGLock только для desktop. Есть два обходных пути:
+
+1. **LAN-режим на компьютере.** Включи галочку LAN, и в настройках Telegram на телефоне укажи прокси с IP компьютера. Работает, пока компьютер включён и телефон в той же сети.
+2. **`tglock-cli` на своём VPS.** Headless-бинарь запускается как systemd-сервис, слушает `0.0.0.0` и пропускает только адреса Telegram — тогда телефон работает откуда угодно, а не только из дома. См. [раздел про CLI](#-без-графического-интерфейса-tglock-cli).
+
+Поддержка Android обсуждается в [#9](https://github.com/by-sonic/tglock/issues/9), сроков нет: Tauri 2 умеет собирать под Android, но перехват трафика там делается через `VpnService` — это другая архитектура, а не пересборка того же кода.
+</details>
+
+<details>
+<summary><b>Замедляет ли TGLock интернет?</b></summary>
+
+Нет. Через прокси идёт **только** трафик Telegram (фильтрация по IP-диапазонам Telegram DC). YouTube, браузер, игры, торренты — всё это идёт напрямую и не замедляется. В этом главное отличие от VPN.
+</details>
+
+<details>
+<summary><b>Apple ругается «приложение не проверено / нельзя открыть»</b></summary>
+
+Сборка пока не подписана и не нотарифицирована — Apple Developer ID стоит $99 в год. Сними карантин Gatekeeper руками: перенеси приложение из `.dmg` в «Программы» и выполни в Терминале
+
+```bash
+xattr -cr /Applications/TGLock.app
+```
+
+После этого приложение запустится двойным кликом из Finder.
+</details>
+
+<details>
+<summary><b>Telegram пишет «прокси не настроен» или сразу отключается</b></summary>
+
+Открой TGLock — он должен показывать **«ПОДКЛЮЧЕНО»** и хотя бы одно активное соединение, когда Telegram пытается работать. Если соединений ноль:
+
+- Не запущен ли уже другой прокси на порту 1080? В TGLock можно поменять порт в настройках.
+- Антивирус/файрвол не блокирует localhost-подключения?
+- В настройках Telegram сервер указан как `127.0.0.1`, не `localhost` — на некоторых системах это разные сетевые стеки.
+- На macOS — убедись что снят Gatekeeper (`xattr -cr ...`).
+</details>
+
+<details>
+<summary><b>Приложение вообще не запускается — окно не появляется</b></summary>
+
+Так проявляется отсутствие 3D-ускорения: интерфейс построен на системном WebView, а тот без ускорения окно не создаёт. Отсюда же случаи «не работает в виртуалке», «не стартует с дефолтным драйвером Microsoft» и «нет монитора».
+
+Начиная с **2.0.0-beta.2** TGLock сам просит у WebView программный рендер, так что на таких машинах должен запускаться. Если хочется вернуть аппаратное ускорение — запусти с переменной `TGLOCK_FORCE_GPU=1`.
+
+Если окно всё равно не появилось, интерфейс тебе и не нужен: возьми [`tglock-cli`](#-без-графического-интерфейса-tglock-cli), которому WebView не требуется вообще. И напиши в [#10](https://github.com/by-sonic/tglock/issues/10) или [#17](https://github.com/by-sonic/tglock/issues/17), что именно за система — это как раз те ишью.
+</details>
+
+<details>
+<summary><b>Порт 1080 уже занят другим приложением</b></summary>
+
+В окне TGLock есть поле **«Порт»** — поменяй на любой свободный (например, `10800`, `1081`, `8888`). После рестарта прокси автоматически обновит deep-link для Telegram. В настройках Telegram укажи новый порт.
+</details>
+
+<details>
+<summary><b>А что если провайдер заблокирует и <code>web.telegram.org</code>?</b></summary>
+
+Это реальный риск, и TGLock 2.0 к нему подготовлен настолько, насколько может.
+
+Маршрут не один: пробуются закреплённые IP Telegram, дублёры `kwsN-1` и системный DNS. Пока жив хотя бы один — туннель поднимается.
+
+Если у твоего провайдера легли **все** маршруты, есть запасной выход — **свой Cloudflare Worker**. Тогда соединение идёт на твой домен `*.workers.dev`, а воркер доводит его до Telegram; блокировать его провайдеру придётся отдельно. Готовый скрипт и пошаговая установка: **[docs/CLOUDFLARE_WORKER.md](docs/CLOUDFLARE_WORKER.md)**. Нужен только аккаунт Cloudflare, бесплатного тарифа хватает, свой сервер и домен не нужны.
+
+Признак, что пора это делать: приложение показывает «Ищем новый маршрут» и не проходит, а в диагностике туннелей 0 и растёт счётчик сбоев. Если Telegram работает — настраивать ничего не надо.
+
+Но честно: если веб-версию Telegram заблокируют так, что её не видно и из датацентров Cloudflare, подход исчерпает себя. TGLock держится на доступности `web.telegram.org`, и никакой запас маршрутов этого не отменяет.
+</details>
+
+<details>
+<summary><b>Можно ли использовать TGLock как обычный SOCKS5 для других приложений?</b></summary>
+
+Смысла нет, и по умолчанию это запрещено.
+
+TGLock определяет Telegram по IP получателя и заворачивает в WebSocket только его. Не-Telegram адреса он релеит напрямую — без шифрования, то есть никакой пользы для обхода в этом нет.
+
+Поэтому такой релей разрешён **только когда прокси слушает `127.0.0.1`**, где до него дотянутся лишь процессы твоего компьютера. На `0.0.0.0` и любом сетевом адресе не-Telegram запросы отклоняются: иначе LAN-режим сделал бы из твоей машины открытый прокси для всего интернета. В `tglock-cli` это можно переопределить флагом `--allow-direct` — но на сетевом адресе ты получишь именно открытый SOCKS5, так что делай это осознанно.
+</details>
+
+<details>
+<summary><b>Где скачать новые версии? Будут ли обновления?</b></summary>
+
+Все релизы — на странице **[GitHub Releases](https://github.com/by-sonic/tglock/releases)**. При пуше тега `v*` GitHub Actions собирает и публикует установщики под Windows x64, macOS (universal) и Linux x64, плюс headless `tglock-cli` под те же три платформы. Подпишись на репозиторий (кнопка **Watch** → **Custom** → **Releases**), чтобы получать уведомления.
+</details>
+
+---
+
+## 🛠 Стек технологий
+
+| Технология | Зачем |
 |---|---|
-| Rust | Один бинарник, нативная скорость |
-| egui | GUI без браузера и Electron |
-| tokio | Async I/O |
-| tokio-tungstenite | WebSocket + TLS |
+| **Rust** | Один бинарник, нативная скорость, без runtime-зависимостей |
+| **Tauri 2** | Нативная оболочка для GUI. Опциональна: за фичей `gui`, в CLI не входит |
+| **TypeScript + Vite** | Интерфейс, внутренняя навигация и строгая типизация |
+| **tokio** | Async I/O, обработка сигналов для корректной остановки сервиса |
+| **tokio-tungstenite** | WebSocket-клиент с TLS поверх `native-tls` |
+| **aes** + **ctr** | Расшифровка MTProto `obfuscated2` init-пакета |
+| **clap** | Разбор аргументов `tglock-cli` |
 
-## Сборка
+Ядро (`src/lib.rs`: разбор MTProto, каскад маршрутов, прокси) не зависит ни от Tauri, ни от оконной системы — поэтому один и тот же код обслуживает и графический интерфейс, и headless-режим.
+
+---
+
+## 🏗 Сборка из исходников
 
 ```bash
 git clone https://github.com/by-sonic/tglock.git
 cd tglock
-cargo build --release
+npm ci
+npm run tauri build
 ```
 
-## VPN
+Результат — `target/release/tglock` (или `tglock.exe` на Windows).
 
-Для обхода блокировок **всех** приложений — **[by sonic VPN](https://t.me/bysonicvpn_bot)**
+Минимальная версия Rust — **1.88** (`rust-version` в `Cargo.toml`, проверяется отдельной задачей в CI). На более старых тулчейнах зависимости не соберутся: часть из них требует edition 2024.
 
-## Лицензия
+### Только CLI, без графики
 
-MIT
+```bash
+cargo build --release --locked --no-default-features --features cli --bin tglock-cli
+```
+
+Ни Node.js, ни фронтенда, ни `libwebkit2gtk` для этого не нужно — при выключенной фиче `gui` Tauri и системный WebView в сборку не попадают вообще. Именно так CLI собирается на голом сервере.
+
+### Проверки, которые гоняет CI
+
+```bash
+cargo fmt --check
+cargo clippy --all-targets -- -D warnings
+cargo clippy --no-default-features --features cli --all-targets -- -D warnings
+cargo test --all-targets
+cargo test --no-default-features --features cli --lib --bins
+```
+
+Тестов 59: разбор `obfuscated2`, каскад маршрутов и его cooldown, протокольные отказы SOCKS5, устойчивость секрета к перезапуску, плюс сквозной тест туннеля против мок-сервера, который реализует сторону Telegram и проверяет, что до неё доходит ровно тот открытый текст, который отправил клиент. Единственный тест с пометкой `#[ignore]` — тот, что требует живой сети.
+
+### Свой релиз через GitHub Actions
+
+Форкни репозиторий и поставь тег `v*` — `.github/workflows/release.yml` соберёт установщики под Windows x64, macOS (universal, Apple Silicon + Intel) и Linux x64, а также `tglock-cli` под те же три платформы, и опубликует их в релизе.
 
 ---
 
-<p align="center"><b>by sonic</b></p>
+## 🤝 Как помочь
+
+Проект живой, PR и баг-репорты разбираются.
+
+- **Нашёл баг** — [открой issue](https://github.com/by-sonic/tglock/issues/new). Полезнее всего: ОС и версия, что показывает вкладка диагностики (маршрут, DC, число сбоев) и провайдер. Для `tglock-cli` — вывод из консоли.
+- **Хочешь фичу** — тоже issue. Если её нет в планах, так и будет написано, без месяцев тишины.
+- **Присылаешь PR** — перед отправкой прогони проверки выше, они те же, что в CI. Небольшие PR ревьюятся быстрее.
+- **Не работает после релиза** — это регрессия, пиши сразу, такие вещи в приоритете.
+
+Известные ограничения, о которых не нужно открывать issue: звонки (UDP), сервисы кроме Telegram (только MTProto), Android и iOS (обсуждается в [#9](https://github.com/by-sonic/tglock/issues/9)).
+
+---
+
+## 📄 Лицензия
+
+[MIT](LICENSE) — делай что хочешь. Форки, модификации, использование в коммерческих проектах — всё разрешено. Ссылка на репозиторий приветствуется, но необязательна.
+
+---
+
+<p align="center">
+  <sub><b>by sonic</b> · <a href="https://github.com/by-sonic/tglock/issues">Issues &amp; feedback</a> · <a href="https://github.com/by-sonic/tglock/releases">Releases</a></sub>
+</p>

build.rs

@@ -0,0 +1,7 @@
+fn main() {
+    // Only the GUI binary needs Tauri's generated context. Without this guard a
+    // headless build would still require the frontend bundle and the WebView
+    // toolchain to be present.
+    #[cfg(feature = "gui")]
+    tauri_build::build();
+}

capabilities/default.json

@@ -0,0 +1,7 @@
+{
+  "$schema": "../gen/schemas/desktop-schema.json",
+  "identifier": "default",
+  "description": "TGLock desktop window",
+  "windows": ["main"],
+  "permissions": ["core:default"]
+}

docs/ARCHITECTURE_V2.md

@@ -0,0 +1,132 @@
+# TGLock 2.0 architecture
+
+## Сборка: ядро, GUI и headless
+
+Крейт собирается в библиотеку и два бинаря:
+
+- `src/lib.rs` — ядро: `mtproto`, `transport`, `proxy`, `config`. Не зависит ни
+  от Tauri, ни от оконной системы;
+- `src/main.rs` — GUI, доступен только при включённой фиче `gui`
+  (`required-features`);
+- `src/bin/cli.rs` — headless `tglock-cli`.
+
+Фича `gui` включена по умолчанию и подтягивает `tauri`, `tauri-build` и `open`.
+При `--no-default-features` ни Tauri, ни системный WebView, ни фронтенд в сборку
+не попадают, и `build.rs` не вызывает `tauri_build`. Так TGLock собирается и
+работает там, где WebView недоступен в принципе: сервер без графического
+окружения, контейнер, машина без монитора. Для случаев, где WebView есть, но нет
+3D-ускорения, GUI дополнительно просит программный рендер — см. Current
+limitations.
+
+## Local protocols
+
+Один TCP-порт автоматически принимает два типа клиентов:
+
+- MTProto proxy с постоянным 16-байтовым secret — основной режим;
+- SOCKS5 без авторизации — режим совместимости.
+
+MTProto init проверяется по secret и transport tag. Из него извлекаются DC,
+признак media-соединения и тип транспорта. Для upstream создаётся новый
+стандартный obfuscated2 init, а последующий поток пере-шифровывается между
+локальным secret и Telegram.
+
+### Различение протоколов
+
+Определять протокол по первому байту нельзя. SOCKS5-приветствие начинается с
+`0x05`, но MTProto init — это 64 случайных байта, и `is_reserved_init`
+исключает только `0xef`, `0xee`, `0xdd`, HTTP-глаголы и заголовок TLS-записи.
+Значение `0x05` попадается примерно в одном init из 256, и такое соединение
+уходило в SOCKS5-ветку и умирало — снаружи это выглядит как «Telegram
+отправляет сообщения через раз».
+
+Поэтому неоднозначный первый байт разрешается так: не потребляя данные,
+ожидается полный 64-байтовый init и делается попытка разобрать его под текущим
+secret. Успешный разбор означает MTProto. Настоящий SOCKS5-клиент присылает
+короткое приветствие и блокируется на ответе, поэтому 64 байта у него не
+появятся и по истечении короткого таймаута он корректно уходит в SOCKS5-ветку.
+
+## Политика прямого релея
+
+Не-Telegram адреса релеятся напрямую, без шифрования, и пользы для обхода в
+этом нет. Поэтому такой релей разрешён только когда прокси слушает loopback,
+где до него дотягиваются лишь локальные процессы. На `0.0.0.0` и любом другом
+сетевом адресе не-Telegram запросы отклоняются кодом SOCKS5 `0x02`, иначе
+LAN-режим превращал бы машину в открытый прокси. Правило выражено в типе
+`config::ListenConfig`, а не в условиях по месту вызова; переопределяется
+только явным `--allow-direct` в CLI.
+
+## Учёт состояния
+
+`Stats::ws` считает **установленные** туннели: счётчик поднимается после
+успешного `transport.connect`, а не перед попыткой. Иначе интерфейс
+рапортовал бы «Telegram на связи», пока рукопожатие ещё перебирает маршруты по
+несколько секунд каждый. Состояния «порт открыт», «идёт перебор маршрутов» и
+«туннель установлен» различимы и в GUI, и в выводе CLI.
+
+Секрет прокси — половина ссылки `tg://proxy`. Для сервиса его нужно закрепить
+файлом (`--secret-file`): под `DynamicUser` и `ProtectHome` домашней папки нет,
+путь по умолчанию не определяется, и секрет генерировался бы заново при каждом
+старте, отключая всех уже настроенных клиентов.
+
+## Transport cascade
+
+Для каждого DC и отдельно для media-соединений строится список маршрутов:
+
+1. сохранённый успешный маршрут;
+2. точный Telegram IP с `kwsN` или `kwsN-1` в TLS SNI и WebSocket Host;
+3. дополнительный Telegram IP, если он определён;
+4. системный DNS;
+5. явно настроенный пользователем Cloudflare Worker.
+
+Поддерживаются DC1–5 и media/CDN DC203. DC203 использует WebSocket-host DC2,
+но подключается к собственному IP.
+
+После ошибки маршрут получает exponential cooldown от 30 секунд до 30 минут.
+Успешный маршрут становится первым для следующего соединения того же DC и
+типа трафика.
+
+## TLS policy
+
+Проверка сертификатов и hostname никогда не отключается. При подключении к
+заданному Telegram IP TCP destination отделён от URI host: TLS продолжает
+проверять сертификат настоящего `kws*.web.telegram.org`.
+
+Cloudflare Worker принимается только как пользовательская настройка. TGLock
+не загружает и не скрывает публичные списки чужих доменов.
+
+## Cloudflare Worker contract
+
+Worker должен принимать WebSocket на:
+
+```text
+/apiws?dst=<telegram-ip>&dc=<dc-id>
+```
+
+и проксировать бинарные frames в TCP `<telegram-ip>:443`. Рекомендуется
+добавить собственную авторизацию до стабильного релиза; поэтому Worker
+остаётся расширенной опцией alpha-версии.
+
+## Current limitations
+
+- SNI camouflage не включена: небезопасное отключение hostname verification
+  из референсной реализации не переносится.
+- Голосовые звонки по UDP не поддерживаются.
+- **GUI зависит от WebView, а тот — от 3D-ускорения.** Начиная с
+  2.0.0-beta.2 приложение перед стартом Tauri само просит программный рендер:
+  на Windows через `WEBVIEW2_ADDITIONAL_BROWSER_ARGUMENTS`, на Linux через
+  `WEBKIT_DISABLE_COMPOSITING_MODE` и `WEBKIT_DISABLE_DMABUF_RENDERER`. Уже
+  заданные оператором значения не перезаписываются, а `TGLOCK_FORCE_GPU=1`
+  возвращает аппаратное ускорение. Для машин без монитора остаётся
+  `tglock-cli`, которому WebView не нужен вовсе (issues #10, #17).
+- Windows-инсталлятор не подписан, macOS-сборка не нотарифицирована, и
+  подписывать их не планируется: сертификат — ежегодный платёж, а проект
+  бесплатный. Часть антивирусов будет реагировать на неподписанный установщик,
+  который открывает локальный сокет и прописывается прокси-сервером — это тот
+  же профиль, по которому ищут прокси-трояны. Вместо доверия предлагаются
+  проверяемые пути: `sha256` каждого артефакта публикуется GitHub на странице
+  релиза, сборка идёт в GitHub Actions из публичного коммита с открытым логом,
+  CLI собирается одной командой. Подробно — в разделе README про антивирус.
+- Работоспособность медиа зависит от конкретного DC аккаунта и доступности
+  Telegram/Cloudflare у провайдера.
+- Пулы заранее открытых WebSocket-соединений будут добавлены после измерения,
+  что они не создают лишнюю нагрузку и не ухудшают стабильность.

docs/CLOUDFLARE_WORKER.md

@@ -0,0 +1,86 @@
+# Резервный маршрут через свой Cloudflare Worker
+
+## Когда это нужно
+
+Только в одном случае: провайдер заблокировал саму веб-инфраструктуру Telegram, и **все** обычные маршруты TGLock перестали отвечать.
+
+Как это выглядит в приложении:
+
+| Что видно | Что это значит | Нужен ли Worker |
+|---|---|---|
+| «Telegram на связи» | туннель работает | нет |
+| «Ищем новый маршрут» и не проходит | маршруты перебираются и все падают | **да** |
+| «Защита включена», DC не определяется | Telegram ещё не подключался | нет, открой Telegram |
+| В диагностике счётчик сбоев растёт, туннелей 0 | ни один маршрут не отвечает | **да** |
+
+В CLI то же самое видно в строке статуса: `туннелей 0 · DC не определён · сбоев 14`.
+
+Если Telegram работает — **ничего настраивать не надо.** Поле Worker в настройках существует для случая, когда обычные маршруты умерли.
+
+Обрати внимание: Worker не спасает, если Telegram недоступен *с самого воркера*. Он помогает, когда домены Telegram заблокированы **у тебя**, а датацентры Cloudflare до них дотягиваются.
+
+## Что понадобится
+
+- аккаунт Cloudflare (бесплатного тарифа достаточно);
+- 10 минут.
+
+Ни своего сервера, ни домена, ни карты не нужно — воркер получит адрес вида `имя.твой-логин.workers.dev`.
+
+## Установка через веб-интерфейс
+
+1. Зайди на [dash.cloudflare.com](https://dash.cloudflare.com) → **Workers & Pages** → **Create application** → **Create Worker**.
+2. Дай имя, например `tglock`. Нажми **Deploy** — сначала задеплоится заготовка, это нормально.
+3. Нажми **Edit code**.
+4. Удали всё содержимое редактора и вставь файл [`worker/tglock-worker.js`](../worker/tglock-worker.js) из этого репозитория целиком.
+5. **Deploy**.
+6. Скопируй адрес воркера. Он показан сверху и выглядит как `tglock.имя.workers.dev` — **без** `https://` и без пути.
+
+### Проверка, что воркер жив
+
+Открой в браузере `https://tglock.имя.workers.dev/apiws`. Должно вернуться `expected a websocket upgrade` — это правильный ответ: значит код развёрнут и работает, просто браузер пришёл обычным запросом.
+
+Если вернулось `not found` — проверь, что путь именно `/apiws`. Если ошибка про `cloudflare:sockets` — у воркера слишком старая дата совместимости, поставь в **Settings → Compatibility date** сегодняшнюю.
+
+## Подключение в TGLock
+
+**В приложении:** Настройки → поле **Cloudflare Worker** → вставь `tglock.имя.workers.dev` → Сохранить. Настройки меняются только при выключенной защите.
+
+**В CLI:** флаг `--worker`, можно повторять:
+
+```bash
+tglock-cli --worker tglock.имя.workers.dev
+tglock-cli --worker первый.workers.dev --worker второй.workers.dev
+```
+
+Worker всегда пробуется **последним**, после всех маршрутов Telegram. Пока обычные маршруты живы, трафик через него не пойдёт, и это осознанно: чужая инфраструктура в цепочке — это лишнее звено, а не улучшение.
+
+## Ограничение доступа
+
+Адрес воркера сам по себе секрет, но лучше поставить токен: **Settings → Variables → Add variable**, имя `TGLOCK_TOKEN`, значение — любая длинная строка.
+
+Пока переменная не задана, проверка токена выключена. Когда задана — воркер начнёт отвечать `403` без параметра `?token=`. Клиент TGLock этот параметр пока не отправляет, так что включать токен есть смысл, если ты правишь и сам скрипт, и адрес.
+
+Независимо от токена воркер соединяется **только** с семью адресами Telegram, которые запрашивает TGLock. Любой другой `dst` получает `403`, так что открытым TCP-прокси он не станет.
+
+## Контракт
+
+Если захочешь написать свою реализацию — вот что именно делает клиент (`src/transport.rs`):
+
+```text
+wss://<домен>/apiws?dst=<telegram-ip>&dc=<номер-dc>
+Sec-WebSocket-Protocol: binary
+```
+
+- `dst` — адрес Telegram, к которому нужно подключиться по TCP на порт 443;
+- `dc` — номер датацентра, для логов;
+- **подпротокол `binary` обязательно нужно подтвердить в ответе** — без этого клиент разорвёт рукопожатие;
+- дальше бинарные frames пересылаются в обе стороны без изменений;
+- TLS до самого воркера обеспечивает Cloudflare.
+
+Список допустимых `dst` совпадает с `transport::worker_allowed_destinations()`.
+
+## Честно про проверку
+
+Скрипт написан по контракту, вычитанному из исходников клиента, и путь с параметрами закреплён тестом `connects_through_the_documented_worker_contract` — он поднимает локальный сервер, который ведёт себя ровно так, как описано выше, и проверяет, что туннель через него поднимается и данные доходят в обе стороны.
+
+Чего этот тест не проверяет: развёрнутый воркер в самом Cloudflare. Если что-то не сойдётся с их API — [открой issue](https://github.com/by-sonic/tglock/issues/new), поправлю.

docs/ISSUE_AUDIT.md

@@ -0,0 +1,89 @@
+# TGLock 2.0 issue audit
+
+Проверено 29 июля 2026 года: все 15 issues и 5 pull requests, существовавшие
+в репозитории на момент аудита.
+
+> **Статус на 30 июля 2026.** Аудит ниже оставлен как есть — это фиксация
+> состояния на дату проверки. Что с тех пор сделано:
+>
+> - Разобраны все issues и pull requests. Открытых PR не осталось.
+> - Закрыты #1–#5, #8, #11, #13, #14, #19, #23 и #3 — с техническими
+>   объяснениями в самих issues.
+> - #15 реализован заново поверх архитектуры 2.0 в #25: смерджить исходный PR
+>   было нельзя, он патчил `bypass.rs`, `network.rs` и `ws_proxy.rs`, которых
+>   больше нет, и правил системный DNS. Взято разделение GUI/CLI и произвольный
+>   bind-адрес; DNS-менеджмент и проверка root отброшены как ненужные.
+> - #12 закрыт: относился к шрифту старого egui-интерфейса.
+> - #10 и #17 закрыты выпуском `v2.0.0-beta.2`: GUI перед стартом просит у
+>   WebView программный рендер. Проверить это на машине без 3D-ускорения
+>   возможности не было, поэтому закрыто как «исправление выпущено», а не
+>   «исправлено» — репортерам предложено переоткрыть, если проблема осталась.
+>   Независимо от WebView работает `tglock-cli`.
+> - #21 закрыт: репорт относился к сборке macOS, которой больше нет, в
+>   `v2.0.0-beta.2` она пересобрана универсальным `.dmg`.
+> - #9 (Android) остаётся единственным открытым — backlog без сроков.
+>
+> Претензия из публичного обсуждения, которую нельзя закрыть кодом: инсталлятор
+> не подписан, из-за чего часть антивирусов на него реагирует. Решение принято
+> и зафиксировано: подписи не будет, сертификат — ежегодный платёж, а проект
+> бесплатный. Вместо неё в README описан механизм срабатывания и три
+> проверяемых пути — сверка `sha256` с публикуемым GitHub digest, открытый лог
+> сборки в Actions и сборка из исходников одной командой.
+>
+> Дополнительно исправлено то, чего в issues не было: коллизия MTProto-init с
+> байтом `0x05` (одно соединение из 256 уходило в SOCKS5-ветку и умирало),
+> подсчёт туннеля до успешного рукопожатия, неверные подписи маршрутов в
+> интерфейсе и генерация нового секрета при каждом старте сервиса. Подробности —
+> в [ARCHITECTURE_V2.md](ARCHITECTURE_V2.md).
+>
+> Из списка «не подтверждённых обещаний» в конце документа закрыты все четыре
+> пункта: формулировки про звонки и про «Подключено» приведены в соответствие с
+> кодом, LAN-режим ограничен адресами Telegram на уровне типа, Cloudflare Worker
+> остаётся исключительно пользовательской настройкой.
+
+## Выводы
+
+Главная причина жалоб «прокси подключён, но Telegram не работает» — приложение
+считало успешный запуск локального SOCKS5-сервера успешным подключением к
+Telegram. Единственный upstream `kws{dc}.web.telegram.org` может резолвиться в
+недоступный IP или блокироваться провайдером.
+
+TGLock 2.0 разделяет эти состояния и использует адаптивный список Telegram IP,
+`kwsN`/`kwsN-1`, системный DNS и опциональный пользовательский Cloudflare
+Worker. TLS SNI и WebSocket Host проверяются. Системный DNS и файл `hosts`
+не изменяются.
+
+## Классификация
+
+| Issue | Наблюдение | Решение для 2.0 |
+|---|---|---|
+| #1 | Порт 1080 занят | Уже есть выбор порта; добавить автоматический подбор |
+| #2, #11 | Неверный сетевой адаптер | В переписанном Rust-ядре привязка исходящего адаптера отсутствует; добавить только как расширенную настройку |
+| #3 | Rust 1.75 не собирает зависимости | `Cargo.lock` зафиксирован; MSRV 1.88 документирована и проверяется в CI |
+| #4 | Linux/серверный режим | Добавить headless CLI и systemd/Docker-примеры |
+| #5 | macOS | Публиковать universal `.app`, затем подписанный и notarized DMG |
+| #8, #19, #21, #23 | Нет подключения | Резервные маршруты, live-probe, понятная диагностика вместо ложного «Подключено» |
+| #9 | Android | Не входит в desktop 2.0; LAN остаётся отдельным сценарием |
+| #10, #17 | GUI не запускается без GPU/монитора | Headless CLI; отдельно проверить software rendering |
+| #13 | Discord/YouTube | Вне области проекта; не смешивать с Telegram-транспортом |
+| #14 | Медиа, звонки, LAN | Медиа тестировать отдельно; звонки не обещать без UDP; LAN ограничить Telegram-адресами |
+
+## Pull requests
+
+- #6 относится к старой Windows-реализации выбора адаптера.
+- #12 относился к шрифту старого GUI. В v2 интерфейс перенесён на Tauri 2 и
+  использует системную типографику каждой платформы.
+- #15 содержит полезное направление разделения GUI/CLI, но основан на старой
+  архитектуре и меняет DNS системы.
+- #18 — экспериментальный Linux GUI без подтверждённого мобильного сценария.
+- #7 не содержит продуктового изменения.
+
+## Не подтверждённые обещания
+
+- Голосовые и видеозвонки нельзя заявлять рабочими: SOCKS5 UDP Associate не
+  реализован, а Telegram может обходить proxy для части звонков.
+- «Подключено» допустимо показывать только после успешного WebSocket handshake,
+  а не после открытия локального порта.
+- LAN-режим не должен становиться открытым универсальным SOCKS5-прокси.
+- Резерв через чужую Cloudflare-инфраструктуру нельзя включать без ясной модели
+  доверия, владельца, мониторинга и политики обновления endpoint-ов.

icons/icon.svg

@@ -0,0 +1,28 @@
+<svg xmlns="http://www.w3.org/2000/svg" width="1024" height="1024" viewBox="0 0 1024 1024">
+  <defs>
+    <linearGradient id="background" x1="150" y1="100" x2="850" y2="930" gradientUnits="userSpaceOnUse">
+      <stop stop-color="#263247"/>
+      <stop offset="0.45" stop-color="#0C1422"/>
+      <stop offset="1" stop-color="#06090F"/>
+    </linearGradient>
+    <linearGradient id="orb" x1="320" y1="260" x2="710" y2="760" gradientUnits="userSpaceOnUse">
+      <stop stop-color="#55BBFF"/>
+      <stop offset="0.48" stop-color="#168EFA"/>
+      <stop offset="1" stop-color="#0756B0"/>
+    </linearGradient>
+    <radialGradient id="glow">
+      <stop stop-color="#38A9FF" stop-opacity=".5"/>
+      <stop offset="1" stop-color="#147AD6" stop-opacity="0"/>
+    </radialGradient>
+    <filter id="shadow" x="-30%" y="-30%" width="160%" height="160%">
+      <feGaussianBlur stdDeviation="28"/>
+    </filter>
+  </defs>
+  <rect x="28" y="28" width="968" height="968" rx="224" fill="url(#background)"/>
+  <rect x="42" y="42" width="940" height="940" rx="210" fill="none" stroke="#FFFFFF" stroke-opacity=".08" stroke-width="4"/>
+  <circle cx="512" cy="512" r="330" fill="url(#glow)" filter="url(#shadow)"/>
+  <circle cx="512" cy="512" r="268" fill="none" stroke="#4AAFFF" stroke-opacity=".15" stroke-width="5"/>
+  <circle cx="512" cy="512" r="220" fill="url(#orb)"/>
+  <circle cx="512" cy="512" r="218" fill="none" stroke="#A5D9FF" stroke-opacity=".58" stroke-width="5"/>
+  <path fill="#fff" d="M690 358 338 494c-24 10-24 22-5 28l90 28 35 107c4 12 3 17 15 17 9 0 13-4 19-10l44-42 92 68c17 10 29 5 33-16l61-285c6-25-10-36-32-31ZM454 544l176-111c9-6 17-2 10 3L496 568l-6 59-36-83Z"/>
+</svg>

index.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.0" />
+    <meta name="theme-color" content="#070a10" />
+    <title>TGLock</title>
+  </head>
+  <body>
+    <div id="app"></div>
+    <script type="module" src="/ui/main.ts"></script>
+  </body>
+</html>

package.json

@@ -0,0 +1,20 @@
+{
+  "name": "tglock-ui",
+  "private": true,
+  "version": "2.0.0-beta.6",
+  "type": "module",
+  "scripts": {
+    "dev": "vite --port 1420",
+    "build": "tsc && vite build",
+    "preview": "vite preview",
+    "tauri": "tauri"
+  },
+  "dependencies": {
+    "@tauri-apps/api": "^2.8.0"
+  },
+  "devDependencies": {
+    "@tauri-apps/cli": "^2.8.0",
+    "typescript": "^5.8.3",
+    "vite": "^6.2.6"
+  }
+}

scripts/verify_bundle_binary.py

@@ -0,0 +1,60 @@
+#!/usr/bin/env python3
+"""Проверяет, что в бандл приложения попал GUI-бинарь, а не headless CLI.
+
+Зачем это существует. В v2.0.0-beta.2 и v2.0.0-beta.3 бандлер Tauri упаковал
+`tglock-cli` как исполняемый файл приложения, и оно не запускалось ни на одной
+платформе. В beta.3 имя файла было уже правильным — бандлер переименовал CLI —
+поэтому проверка имени или `CFBundleExecutable` ничего не заметила. Отличить
+можно только по содержимому.
+
+Почему на Python, а не grep. BSD grep на macOS в UTF-8-локали молча не находит
+строки в бинарных данных там, где GNU grep находит: проверка проходила на
+Linux и давала ложное «не GUI» на macOS. Один скрипт для всех платформ и для
+всех трёх мест, где проверка вызывается, исключает подобные расхождения.
+
+Использование:
+    python3 scripts/verify_bundle_binary.py <путь-к-бинарю>
+"""
+
+import sys
+
+# Присутствуют только в GUI: строка CSP из tauri.conf.json и имя движка WebView.
+GUI_MARKERS = (b"ipc.localhost", b"wry")
+# Присутствуют только в CLI: имена флагов clap.
+CLI_MARKERS = (b"allow-direct", b"secret-file")
+
+
+def main(argv: list[str]) -> int:
+    if len(argv) != 2:
+        print(f"использование: {argv[0]} <путь-к-бинарю>", file=sys.stderr)
+        return 2
+
+    path = argv[1]
+    try:
+        with open(path, "rb") as handle:
+            data = handle.read()
+    except OSError as error:
+        print(f"не удалось прочитать {path}: {error}", file=sys.stderr)
+        return 1
+
+    found_gui = [marker.decode() for marker in GUI_MARKERS if marker in data]
+    found_cli = [marker.decode() for marker in CLI_MARKERS if marker in data]
+
+    print(f"файл:     {path}")
+    print(f"размер:   {len(data) / 1048576:.1f} МБ")
+    print(f"GUI:      {found_gui or 'признаков нет'}")
+    print(f"CLI:      {found_cli or 'признаков нет'}")
+
+    if found_cli:
+        print("ОШИБКА: в бандле headless CLI вместо приложения", file=sys.stderr)
+        return 1
+    if not found_gui:
+        print("ОШИБКА: это не GUI-бинарь, признаков GUI нет", file=sys.stderr)
+        return 1
+
+    print("OK: в бандле GUI-бинарь")
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main(sys.argv))

src/bin/cli.rs

@@ -0,0 +1,377 @@
+//! TGLock without a graphical interface.
+//!
+//! Built with `--no-default-features` this binary links neither Tauri nor a
+//! system WebView, so it runs on servers, in containers and on machines with no
+//! GPU or monitor — the cases that make the GUI fail to start at all
+//! (by-sonic/tglock#10, by-sonic/tglock#17).
+
+use clap::Parser;
+use std::net::IpAddr;
+use std::path::PathBuf;
+use std::process::ExitCode;
+use std::sync::atomic::Ordering;
+use std::sync::Arc;
+use std::time::Duration;
+use tglock::cli_settings as config;
+use tglock::{proxy, transport};
+
+const STATUS_POLL: Duration = Duration::from_secs(1);
+
+/// Напечатать строку, вернув `false`, если stdout больше не принимает данные.
+///
+/// `println!` при ошибке записи паникует, а у демона stdout исчезает штатно: его
+/// пускают в `head`, закрывают терминал, перезапускают сборщик логов. Падать из
+/// за этого туннель не должен — он продолжает работать молча.
+fn say(text: &str) -> bool {
+    use std::io::Write;
+    let mut out = std::io::stdout().lock();
+    writeln!(out, "{text}").and_then(|()| out.flush()).is_ok()
+}
+
+#[derive(Debug, Parser)]
+#[command(
+    name = "tglock-cli",
+    version,
+    about = "TGLock без графического интерфейса: локальный MTProto-прокси через WebSocket"
+)]
+struct Args {
+    /// Файл настроек. Если не задан, ищется tglock.toml рядом с бинарём
+    #[arg(short, long, value_name = "PATH")]
+    config: Option<PathBuf>,
+
+    /// Адрес для прослушивания. По умолчанию 127.0.0.1 — только этот компьютер
+    #[arg(short, long, value_name = "IP")]
+    bind: Option<IpAddr>,
+
+    /// Порт локального прокси. По умолчанию 1080
+    #[arg(short, long, value_name = "PORT")]
+    port: Option<u16>,
+
+    /// То же, что --bind 0.0.0.0: доступ с других устройств в локальной сети
+    #[arg(long, conflicts_with = "bind")]
+    lan: bool,
+
+    /// Домен своего Cloudflare Worker как резервный маршрут. Можно повторять
+    #[arg(long, value_name = "DOMAIN")]
+    worker: Vec<String>,
+
+    /// Проксировать и не-Telegram адреса. На сетевом адресе это открытый SOCKS5
+    #[arg(long)]
+    allow_direct: bool,
+
+    /// Файл с секретом прокси. Для сервиса нужен он или secret в настройках:
+    /// иначе после перезапуска секрет будет новым и настроенные клиенты отвалятся
+    #[arg(long, value_name = "PATH")]
+    secret_file: Option<PathBuf>,
+
+    /// Печатать только ошибки
+    #[arg(short, long)]
+    quiet: bool,
+}
+
+impl Args {
+    fn overrides(&self) -> config::Overrides {
+        config::Overrides {
+            bind: self.bind,
+            port: self.port,
+            lan: self.lan,
+            allow_direct: self.allow_direct,
+            worker: self.worker.clone(),
+            secret_file: self.secret_file.clone(),
+            quiet: self.quiet,
+        }
+    }
+
+    /// Файл настроек и путь, по которому он найден.
+    ///
+    /// Явный `--config` обязателен к существованию: если человек указал путь и
+    /// опечатался, молча стартовать с настройками по умолчанию — худшее из
+    /// возможных поведений.
+    fn load_file(&self) -> Result<(config::FileConfig, Option<PathBuf>), String> {
+        if let Some(path) = &self.config {
+            return Ok((config::FileConfig::load(path)?, Some(path.clone())));
+        }
+        match config::path_next_to_executable() {
+            Some(path) if path.is_file() => Ok((config::FileConfig::load(&path)?, Some(path))),
+            _ => Ok((config::FileConfig::default(), None)),
+        }
+    }
+}
+
+fn main() -> ExitCode {
+    let args = Args::parse();
+    let runtime = match tokio::runtime::Runtime::new() {
+        Ok(runtime) => runtime,
+        Err(error) => {
+            eprintln!("tglock-cli: не удалось запустить среду выполнения: {error}");
+            return ExitCode::FAILURE;
+        }
+    };
+
+    match runtime.block_on(serve(args)) {
+        Ok(()) => ExitCode::SUCCESS,
+        Err(error) => {
+            eprintln!("tglock-cli: {error}");
+            ExitCode::FAILURE
+        }
+    }
+}
+
+async fn serve(args: Args) -> Result<(), String> {
+    let (file, file_path) = args.load_file()?;
+    let settings = config::resolve(file, args.overrides())?;
+    let listen = settings.listen;
+    let stats = settings.stats();
+    let quiet = settings.quiet;
+
+    // Bind before printing anything: a busy port must be an error, not a
+    // daemon that reports success and silently does nothing.
+    let listener = proxy::bind(listen).await?;
+
+    if !quiet {
+        let intro = match &file_path {
+            Some(path) => format!("Настройки: {}", path.display()),
+            None => format!(
+                "Настройки: только флаги ({} рядом с бинарём не найден)",
+                config::DEFAULT_FILE_NAME
+            ),
+        };
+        say(&intro);
+        say(&format!("Слушаю {}", listen.addr));
+        say(&format!(
+            "Ссылка для Telegram: {}",
+            listen.telegram_link(&stats.telegram_secret())
+        ));
+        if matches!(settings.secret, config::SecretSource::Ephemeral) {
+            say(
+                "Внимание: секрет не закреплён и будет новым после перезапуска — \
+                 задайте secret в настройках или --secret-file",
+            );
+        }
+        if listen.allow_direct && !listen.addr.ip().is_loopback() {
+            say(&format!(
+                "Внимание: allow_direct на адресе {} превращает TGLock в открытый SOCKS5-прокси",
+                listen.addr.ip()
+            ));
+        } else if !listen.allow_direct {
+            say("Пропускаю только адреса Telegram");
+        }
+        if !settings.workers.is_empty() {
+            say(&format!("Резервные Worker-домены: {}", settings.workers));
+        }
+    }
+
+    let server_stats = stats.clone();
+    let mut server =
+        tokio::spawn(
+            async move { proxy::serve(server_stats, listener, listen.allow_direct).await },
+        );
+    let watcher = (!quiet).then(|| tokio::spawn(watch_status(stats.clone())));
+
+    let outcome = tokio::select! {
+        joined = &mut server => joined.map_err(|error| format!("рабочая задача упала: {error}"))?,
+        signal = shutdown_signal() => {
+            signal.map_err(|error| format!("обработчик сигналов: {error}"))?;
+            if !quiet {
+                say("Получен сигнал остановки, закрываю соединения…");
+            }
+            stats.stop();
+            server
+                .await
+                .map_err(|error| format!("рабочая задача упала: {error}"))?
+        }
+    };
+
+    if let Some(watcher) = watcher {
+        watcher.abort();
+    }
+    outcome
+}
+
+/// Print a line whenever the tunnel state changes.
+///
+/// This is the text equivalent of the GUI diagnostics tab: without it a daemon
+/// gives journald nothing to show when Telegram stops working.
+async fn watch_status(stats: Arc<proxy::Stats>) {
+    let mut previous = None;
+    loop {
+        tokio::time::sleep(STATUS_POLL).await;
+        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.ws_failures.load(Ordering::Relaxed),
+        );
+        if previous.as_ref() == Some(&current) {
+            continue;
+        }
+        let (active, tunnels, dc, route, failures) = current;
+        let line = format!(
+            "соединений {active} · туннелей {tunnels} · {} · {} · сбоев {failures}",
+            if dc > 0 {
+                format!("DC{dc}")
+            } else {
+                "DC не определён".to_owned()
+            },
+            transport::route_label(route)
+        );
+        // Закрытый stdout — не ошибка: печатать больше некому, туннель работает
+        // дальше без наблюдателя.
+        if !say(&line) {
+            return;
+        }
+        previous = Some(current);
+    }
+}
+
+/// Ctrl+C everywhere, plus SIGTERM on unix so `systemctl stop` shuts the
+/// tunnel down cleanly instead of killing it.
+#[cfg(unix)]
+async fn shutdown_signal() -> std::io::Result<()> {
+    use tokio::signal::unix::{signal, SignalKind};
+
+    let mut terminate = signal(SignalKind::terminate())?;
+    tokio::select! {
+        result = tokio::signal::ctrl_c() => result,
+        _ = terminate.recv() => Ok(()),
+    }
+}
+
+#[cfg(not(unix))]
+async fn shutdown_signal() -> std::io::Result<()> {
+    tokio::signal::ctrl_c().await
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use clap::CommandFactory;
+
+    fn parse(args: &[&str]) -> Args {
+        Args::try_parse_from(std::iter::once("tglock-cli").chain(args.iter().copied())).unwrap()
+    }
+
+    /// Итоговые настройки только из флагов, без файла.
+    fn from_flags(args: &[&str]) -> config::Resolved {
+        config::resolve(config::FileConfig::default(), parse(args).overrides()).unwrap()
+    }
+
+    #[test]
+    fn command_definition_is_valid() {
+        Args::command().debug_assert();
+    }
+
+    #[test]
+    fn defaults_to_loopback_on_the_default_port() {
+        let listen = from_flags(&[]).listen;
+        assert_eq!(listen.addr.to_string(), "127.0.0.1:1080");
+        assert!(listen.allow_direct);
+    }
+
+    #[test]
+    fn lan_flag_matches_explicit_wildcard_bind() {
+        assert_eq!(
+            from_flags(&["--lan"]).listen,
+            from_flags(&["-b", "0.0.0.0"]).listen
+        );
+    }
+
+    #[test]
+    fn lan_does_not_relay_non_telegram_traffic() {
+        let listen = from_flags(&["--lan"]).listen;
+        assert_eq!(listen.addr.to_string(), "0.0.0.0:1080");
+        assert!(!listen.allow_direct);
+    }
+
+    #[test]
+    fn allow_direct_is_the_only_way_to_open_a_network_listener() {
+        assert!(!from_flags(&["-b", "192.168.1.10"]).listen.allow_direct);
+        assert!(
+            from_flags(&["-b", "192.168.1.10", "--allow-direct"])
+                .listen
+                .allow_direct
+        );
+    }
+
+    #[test]
+    fn bind_and_port_are_honoured() {
+        let listen = from_flags(&["--bind", "10.0.0.7", "--port", "1443"]).listen;
+        assert_eq!(listen.addr.to_string(), "10.0.0.7:1443");
+    }
+
+    #[test]
+    fn ipv6_bind_is_accepted() {
+        let listen = from_flags(&["-b", "::1", "-p", "2080"]).listen;
+        assert_eq!(listen.addr.to_string(), "[::1]:2080");
+        assert!(listen.allow_direct);
+    }
+
+    #[test]
+    fn repeated_worker_flags_collapse_into_one_list() {
+        let settings = from_flags(&["--worker", "a.workers.dev", "--worker", "b.workers.dev"]);
+        assert_eq!(settings.workers, "a.workers.dev,b.workers.dev");
+    }
+
+    #[test]
+    fn no_worker_flag_means_no_domains() {
+        assert!(from_flags(&[]).workers.is_empty());
+    }
+
+    #[test]
+    fn lan_and_explicit_bind_cannot_be_combined() {
+        assert!(Args::try_parse_from(["tglock-cli", "--lan", "-b", "127.0.0.1"]).is_err());
+    }
+
+    #[test]
+    fn a_pinned_secret_file_survives_a_restart() {
+        let path = std::env::temp_dir().join(format!(
+            "tglock-cli-secret-{}-{:?}",
+            std::process::id(),
+            std::thread::current().id()
+        ));
+        let _ = std::fs::remove_file(&path);
+
+        let first = from_flags(&["--secret-file", path.to_str().unwrap()])
+            .stats()
+            .telegram_secret();
+        let second = from_flags(&["--secret-file", path.to_str().unwrap()])
+            .stats()
+            .telegram_secret();
+
+        assert_eq!(
+            first, second,
+            "a restart must advertise the same tg:// secret"
+        );
+        assert!(first.starts_with("dd"));
+
+        // A corrupted file must not wedge the daemon: it is replaced.
+        std::fs::write(&path, "garbage").unwrap();
+        let third = from_flags(&["--secret-file", path.to_str().unwrap()])
+            .stats()
+            .telegram_secret();
+        assert_ne!(third, first);
+        let fourth = from_flags(&["--secret-file", path.to_str().unwrap()])
+            .stats()
+            .telegram_secret();
+        assert_eq!(third, fourth, "the replacement must be persisted in turn");
+
+        let _ = std::fs::remove_file(&path);
+    }
+
+    #[test]
+    fn rejects_malformed_values() {
+        for bad in [
+            vec!["-b", "not-an-ip"],
+            vec!["-p", "70000"],
+            vec!["-p", "-1"],
+            vec!["--unknown"],
+        ] {
+            assert!(
+                Args::try_parse_from(std::iter::once("tglock-cli").chain(bad.iter().copied()))
+                    .is_err(),
+                "{bad:?} must be rejected"
+            );
+        }
+    }
+}

src/cli_settings.rs

@@ -0,0 +1,360 @@
+//! Файл конфигурации для `tglock-cli`.
+//!
+//! Живёт в библиотеке, а не рядом с бинарём: каталожная форма `src/bin/cli/`
+//! ломает перечисление бинарей в Tauri — он выводит имя приложения из имени
+//! каталога и пытается упаковать несуществующий `cli`.
+//!
+//! Запрошен в by-sonic/tglock#32: держать все параметры и секрет в одном месте,
+//! чтобы не собирать батник с ключами при каждом запуске.
+//!
+//! Порядок приоритетов: значения по умолчанию → файл → флаги командной строки.
+//! Флаги-переключатели (`--lan`, `--allow-direct`, `--quiet`) могут только
+//! включать: их отсутствие означает «взять из файла», а не «выключить».
+
+use crate::config::ListenConfig;
+use crate::{mtproto, proxy};
+use serde::Deserialize;
+use std::net::IpAddr;
+use std::path::{Path, PathBuf};
+
+/// Имя файла, который ищется рядом с бинарём, если `--config` не задан.
+pub const DEFAULT_FILE_NAME: &str = "tglock.toml";
+
+/// Содержимое файла конфигурации.
+///
+/// `deny_unknown_fields` намеренно: опечатка вроде `porrt = 1080` должна быть
+/// ошибкой при старте, а не молча проигнорированной строкой, из-за которой
+/// сервис слушает не тот порт.
+#[derive(Debug, Default, Deserialize, PartialEq)]
+#[serde(deny_unknown_fields)]
+pub struct FileConfig {
+    pub bind: Option<IpAddr>,
+    pub port: Option<u16>,
+    pub lan: Option<bool>,
+    pub allow_direct: Option<bool>,
+    pub worker: Option<Vec<String>>,
+    pub secret: Option<String>,
+    pub secret_file: Option<PathBuf>,
+    pub quiet: Option<bool>,
+}
+
+impl FileConfig {
+    pub fn parse(text: &str) -> Result<Self, String> {
+        toml::from_str(text).map_err(|error| format!("конфиг разобрать не удалось: {error}"))
+    }
+
+    pub fn load(path: &Path) -> Result<Self, String> {
+        let text = std::fs::read_to_string(path)
+            .map_err(|error| format!("не удалось прочитать {}: {error}", path.display()))?;
+        Self::parse(&text)
+    }
+}
+
+/// Значения, пришедшие из командной строки.
+#[derive(Debug, Default)]
+pub struct Overrides {
+    pub bind: Option<IpAddr>,
+    pub port: Option<u16>,
+    pub lan: bool,
+    pub allow_direct: bool,
+    pub worker: Vec<String>,
+    pub secret_file: Option<PathBuf>,
+    pub quiet: bool,
+}
+
+/// Откуда взять секрет прокси.
+#[derive(Debug, PartialEq)]
+pub enum SecretSource {
+    /// Записан прямо в конфиге.
+    Inline([u8; 16]),
+    /// Лежит в отдельном файле, создаётся при первом запуске.
+    File(PathBuf),
+    /// Ни того, ни другого: секрет будет новым при каждом старте.
+    Ephemeral,
+}
+
+/// Итоговые настройки запуска.
+#[derive(Debug, PartialEq)]
+pub struct Resolved {
+    pub listen: ListenConfig,
+    /// Домены Worker'ов в том виде, в каком их ждёт `Stats::set_worker_domain`.
+    pub workers: String,
+    pub secret: SecretSource,
+    pub quiet: bool,
+}
+
+impl Resolved {
+    pub fn stats(&self) -> std::sync::Arc<proxy::Stats> {
+        let stats = match &self.secret {
+            SecretSource::Inline(secret) => proxy::Stats::with_secret(*secret),
+            SecretSource::File(path) => {
+                proxy::Stats::with_secret(mtproto::load_or_create_secret_at(path))
+            }
+            SecretSource::Ephemeral => proxy::Stats::new(),
+        };
+        stats.set_worker_domain(&self.workers);
+        stats
+    }
+}
+
+/// Свести файл и флаги в одни настройки.
+pub fn resolve(file: FileConfig, cli: Overrides) -> Result<Resolved, String> {
+    let port = cli.port.or(file.port).unwrap_or(proxy::DEFAULT_PORT);
+    if port == 0 {
+        return Err("порт должен быть от 1 до 65535".to_owned());
+    }
+
+    let lan = cli.lan || file.lan.unwrap_or(false);
+    let bind = cli.bind.or(file.bind);
+    if lan && bind.is_some() {
+        return Err("нельзя задать одновременно lan и bind: выберите одно".to_owned());
+    }
+
+    let listen = match (lan, bind) {
+        (true, _) => ListenConfig::lan(port),
+        (false, Some(ip)) => ListenConfig::new(ip, port),
+        (false, None) => ListenConfig::loopback(port),
+    };
+    let allow_direct = cli.allow_direct || file.allow_direct.unwrap_or(false);
+    let listen = if allow_direct {
+        listen.with_allow_direct(true)
+    } else {
+        listen
+    };
+
+    let workers = if cli.worker.is_empty() {
+        file.worker.unwrap_or_default()
+    } else {
+        cli.worker
+    };
+
+    // Секрет из файла конфигурации важнее отдельного файла: если человек вписал
+    // его сюда, значит хотел держать всё в одном месте.
+    let secret = match (&file.secret, cli.secret_file.or(file.secret_file)) {
+        (Some(value), _) => SecretSource::Inline(
+            mtproto::parse_secret(value)
+                .ok_or("секрет в конфиге неверный: нужны 32 hex-символа, можно с префиксом dd")?,
+        ),
+        (None, Some(path)) => SecretSource::File(path),
+        (None, None) => SecretSource::Ephemeral,
+    };
+
+    Ok(Resolved {
+        listen,
+        workers: workers.join(","),
+        secret,
+        quiet: cli.quiet || file.quiet.unwrap_or(false),
+    })
+}
+
+/// Путь к конфигу рядом с исполняемым файлом.
+///
+/// Именно этого просили в #32: «размещение рядом с бинарником частично решает
+/// вопрос». Текущий каталог не используется, чтобы сервис не зависел от того,
+/// откуда его запустили.
+pub fn path_next_to_executable() -> Option<PathBuf> {
+    let executable = std::env::current_exe().ok()?;
+    Some(executable.parent()?.join(DEFAULT_FILE_NAME))
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    const SECRET: &str = "00112233445566778899aabbccddeeff";
+
+    fn cli() -> Overrides {
+        Overrides::default()
+    }
+
+    #[test]
+    fn empty_config_and_no_flags_give_the_documented_defaults() {
+        let resolved = resolve(FileConfig::default(), cli()).unwrap();
+        assert_eq!(resolved.listen.addr.to_string(), "127.0.0.1:1080");
+        assert!(resolved.listen.allow_direct);
+        assert_eq!(resolved.workers, "");
+        assert_eq!(resolved.secret, SecretSource::Ephemeral);
+        assert!(!resolved.quiet);
+    }
+
+    #[test]
+    fn file_values_are_used_when_no_flags_are_given() {
+        let file = FileConfig::parse(
+            r#"
+            bind = "10.0.0.5"
+            port = 1443
+            allow_direct = true
+            worker = ["a.workers.dev", "b.workers.dev"]
+            quiet = true
+        "#,
+        )
+        .unwrap();
+        let resolved = resolve(file, cli()).unwrap();
+        assert_eq!(resolved.listen.addr.to_string(), "10.0.0.5:1443");
+        assert!(resolved.listen.allow_direct);
+        assert_eq!(resolved.workers, "a.workers.dev,b.workers.dev");
+        assert!(resolved.quiet);
+    }
+
+    #[test]
+    fn flags_win_over_the_file() {
+        let file = FileConfig::parse(
+            r#"
+            bind = "10.0.0.5"
+            port = 1443
+            worker = ["from-file.workers.dev"]
+        "#,
+        )
+        .unwrap();
+        let resolved = resolve(
+            file,
+            Overrides {
+                bind: Some("192.168.1.7".parse().unwrap()),
+                port: Some(2080),
+                worker: vec!["from-flag.workers.dev".to_owned()],
+                ..Overrides::default()
+            },
+        )
+        .unwrap();
+        assert_eq!(resolved.listen.addr.to_string(), "192.168.1.7:2080");
+        assert_eq!(resolved.workers, "from-flag.workers.dev");
+    }
+
+    #[test]
+    fn a_switch_flag_can_only_turn_things_on() {
+        // Отсутствие --quiet не должно отменять quiet = true из файла: иначе
+        // файл нельзя было бы использовать для включения ничего.
+        let file = FileConfig::parse("quiet = true\nallow_direct = true").unwrap();
+        let resolved = resolve(file, cli()).unwrap();
+        assert!(resolved.quiet);
+        assert!(resolved.listen.allow_direct);
+    }
+
+    #[test]
+    fn lan_from_the_file_restricts_to_telegram() {
+        let resolved = resolve(FileConfig::parse("lan = true").unwrap(), cli()).unwrap();
+        assert_eq!(resolved.listen.addr.to_string(), "0.0.0.0:1080");
+        assert!(
+            !resolved.listen.allow_direct,
+            "сетевой слушатель не должен релеить произвольные адреса без явного разрешения"
+        );
+    }
+
+    #[test]
+    fn lan_and_bind_together_are_rejected_wherever_they_come_from() {
+        let both_in_file = FileConfig::parse("lan = true\nbind = \"10.0.0.5\"").unwrap();
+        assert!(resolve(both_in_file, cli()).is_err());
+
+        let file = FileConfig::parse("bind = \"10.0.0.5\"").unwrap();
+        let flag_lan = Overrides {
+            lan: true,
+            ..Overrides::default()
+        };
+        assert!(
+            resolve(file, flag_lan).is_err(),
+            "конфликт должен ловиться и когда стороны пришли из разных мест"
+        );
+    }
+
+    #[test]
+    fn inline_secret_is_accepted_in_both_written_forms() {
+        for value in [SECRET.to_owned(), format!("dd{SECRET}")] {
+            let file = FileConfig::parse(&format!("secret = \"{value}\"")).unwrap();
+            let resolved = resolve(file, cli()).unwrap();
+            assert_eq!(
+                resolved.secret,
+                SecretSource::Inline([
+                    0x00, 0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77, 0x88, 0x99, 0xaa, 0xbb, 0xcc,
+                    0xdd, 0xee, 0xff,
+                ]),
+                "форма {value} должна приниматься"
+            );
+        }
+    }
+
+    #[test]
+    fn a_broken_inline_secret_stops_the_start() {
+        let file = FileConfig::parse("secret = \"явно не секрет\"").unwrap();
+        let error = resolve(file, cli()).unwrap_err();
+        assert!(
+            error.contains("32"),
+            "ошибка должна объяснять формат, получено: {error}"
+        );
+    }
+
+    #[test]
+    fn inline_secret_wins_over_a_secret_file() {
+        let file =
+            FileConfig::parse(&format!("secret = \"{SECRET}\"\nsecret_file = \"s.bin\"")).unwrap();
+        let resolved = resolve(file, cli()).unwrap();
+        assert!(matches!(resolved.secret, SecretSource::Inline(_)));
+    }
+
+    #[test]
+    fn secret_file_from_the_flag_wins_over_the_file() {
+        let file = FileConfig::parse("secret_file = \"from-file.bin\"").unwrap();
+        let resolved = resolve(
+            file,
+            Overrides {
+                secret_file: Some(PathBuf::from("from-flag.bin")),
+                ..Overrides::default()
+            },
+        )
+        .unwrap();
+        assert_eq!(
+            resolved.secret,
+            SecretSource::File(PathBuf::from("from-flag.bin"))
+        );
+    }
+
+    #[test]
+    fn a_typo_in_the_config_is_an_error_not_a_silent_default() {
+        // Самая опасная поломка конфига — та, которую не видно. Сервис не должен
+        // слушать 1080, если человек написал porrt = 1443.
+        let error = FileConfig::parse("porrt = 1443").unwrap_err();
+        assert!(
+            error.contains("porrt"),
+            "ошибка должна называть неизвестное поле, получено: {error}"
+        );
+    }
+
+    #[test]
+    fn malformed_values_are_rejected() {
+        for text in [
+            "bind = \"не адрес\"",
+            "port = \"1080\"",
+            "port = 70000",
+            "worker = \"строка вместо списка\"",
+            "lan = \"да\"",
+        ] {
+            assert!(
+                FileConfig::parse(text).is_err(),
+                "{text:?} должен быть отвергнут"
+            );
+        }
+    }
+
+    #[test]
+    fn zero_port_is_rejected() {
+        assert!(resolve(FileConfig::parse("port = 0").unwrap(), cli()).is_err());
+    }
+
+    #[test]
+    fn comments_and_blank_lines_are_fine() {
+        let file = FileConfig::parse(
+            r#"
+            # порт для второго экземпляра
+            port = 1081
+
+            # свой воркер как резерв
+            worker = ["backup.workers.dev"]
+        "#,
+        )
+        .unwrap();
+        assert_eq!(file.port, Some(1081));
+        assert_eq!(
+            file.worker.as_deref(),
+            Some(&["backup.workers.dev".to_owned()][..])
+        );
+    }
+}

src/config.rs

@@ -0,0 +1,135 @@
+//! Listener configuration shared by the GUI and the CLI.
+
+use std::net::{IpAddr, Ipv4Addr, SocketAddr};
+
+/// Where the local proxy listens and whether it is allowed to relay anything
+/// other than Telegram.
+#[derive(Clone, Copy, Debug, Eq, PartialEq)]
+pub struct ListenConfig {
+    pub addr: SocketAddr,
+    /// Relay non-Telegram destinations as a plain SOCKS5 proxy.
+    ///
+    /// Loopback listeners get this for free because only local processes can
+    /// reach them. A listener the network can reach must opt in explicitly, so
+    /// that sharing TGLock across a flat never silently turns the machine into
+    /// an open SOCKS5 relay.
+    pub allow_direct: bool,
+}
+
+impl ListenConfig {
+    /// Listener with the default policy for the given address.
+    pub fn new(ip: IpAddr, port: u16) -> Self {
+        Self {
+            addr: SocketAddr::new(ip, port),
+            allow_direct: ip.is_loopback(),
+        }
+    }
+
+    /// `127.0.0.1` — only this machine, non-Telegram traffic relayed.
+    pub fn loopback(port: u16) -> Self {
+        Self::new(IpAddr::V4(Ipv4Addr::LOCALHOST), port)
+    }
+
+    /// `0.0.0.0` — reachable from the local network, Telegram destinations only.
+    pub fn lan(port: u16) -> Self {
+        Self::new(IpAddr::V4(Ipv4Addr::UNSPECIFIED), port)
+    }
+
+    /// Override the direct-relay policy. Used by `--allow-direct`.
+    pub fn with_allow_direct(mut self, allow_direct: bool) -> Self {
+        self.allow_direct = allow_direct;
+        self
+    }
+
+    /// Host to advertise in a `tg://proxy` link for this listener.
+    ///
+    /// A wildcard bind is not a usable destination, so it is resolved to the
+    /// address this machine uses to reach the network.
+    pub fn advertised_host(&self) -> String {
+        let ip = self.addr.ip();
+        if ip.is_unspecified() {
+            outbound_ip().unwrap_or_else(|| Ipv4Addr::LOCALHOST.to_string())
+        } else {
+            ip.to_string()
+        }
+    }
+
+    /// `tg://proxy` link that points Telegram at this listener.
+    pub fn telegram_link(&self, secret: &str) -> String {
+        format!(
+            "tg://proxy?server={}&port={}&secret={}",
+            self.advertised_host(),
+            self.addr.port(),
+            secret
+        )
+    }
+}
+
+/// Local address of the interface that reaches the default route.
+///
+/// No packet is sent: connecting a UDP socket only makes the OS pick a route.
+fn outbound_ip() -> Option<String> {
+    let socket = std::net::UdpSocket::bind("0.0.0.0:0").ok()?;
+    socket.connect("8.8.8.8:80").ok()?;
+    Some(socket.local_addr().ok()?.ip().to_string())
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn loopback_relays_direct_traffic() {
+        let config = ListenConfig::loopback(1080);
+        assert_eq!(config.addr.to_string(), "127.0.0.1:1080");
+        assert!(config.allow_direct);
+    }
+
+    #[test]
+    fn lan_restricts_to_telegram_by_default() {
+        let config = ListenConfig::lan(1080);
+        assert_eq!(config.addr.to_string(), "0.0.0.0:1080");
+        assert!(!config.allow_direct);
+    }
+
+    #[test]
+    fn any_routable_address_restricts_to_telegram() {
+        for ip in ["192.168.1.10", "10.0.0.5", "::"] {
+            let config = ListenConfig::new(ip.parse().unwrap(), 1080);
+            assert!(
+                !config.allow_direct,
+                "{ip} must not relay non-Telegram traffic without an explicit opt-in"
+            );
+        }
+    }
+
+    #[test]
+    fn ipv6_loopback_is_treated_as_local() {
+        let config = ListenConfig::new("::1".parse().unwrap(), 1080);
+        assert!(config.allow_direct);
+        assert_eq!(config.addr.to_string(), "[::1]:1080");
+    }
+
+    #[test]
+    fn allow_direct_override_is_explicit_in_both_directions() {
+        assert!(ListenConfig::lan(1080).with_allow_direct(true).allow_direct);
+        assert!(
+            !ListenConfig::loopback(1080)
+                .with_allow_direct(false)
+                .allow_direct
+        );
+    }
+
+    #[test]
+    fn link_uses_concrete_host_and_port() {
+        let link = ListenConfig::new("192.168.1.10".parse().unwrap(), 1443).telegram_link("ddaa");
+        assert_eq!(link, "tg://proxy?server=192.168.1.10&port=1443&secret=ddaa");
+    }
+
+    #[test]
+    fn wildcard_bind_never_advertises_itself() {
+        let host = ListenConfig::lan(1080).advertised_host();
+        assert_ne!(host, "0.0.0.0");
+        assert!(!host.is_empty());
+    }
+}

src/lib.rs

@@ -0,0 +1,15 @@
+//! TGLock core: the MTProto/WebSocket transport shared by the desktop GUI and
+//! the headless CLI.
+//!
+//! Nothing in this crate depends on Tauri or on a windowing system, so the
+//! `tglock-cli` binary can be built with `--no-default-features` on a server
+//! that has neither a GPU nor a monitor.
+
+pub mod config;
+pub mod mtproto;
+pub mod proxy;
+pub mod transport;
+
+/// Настройки headless-версии: файл конфигурации и сведение с флагами.
+#[cfg(feature = "cli")]
+pub mod cli_settings;

src/main.rs

@@ -1,365 +1,341 @@
 #![cfg_attr(not(debug_assertions), windows_subsystem = "windows")]
 
-mod proxy;
-
+use serde::{Deserialize, Serialize};
+use std::path::PathBuf;
 use std::sync::atomic::Ordering;
 use std::sync::{Arc, Mutex};
-use std::time::Instant;
+use std::time::{Instant, SystemTime, UNIX_EPOCH};
+use tauri::{Manager, State};
+use tglock::config::ListenConfig;
+use tglock::{proxy, transport};
 
-use eframe::egui;
+#[derive(Clone, Debug, Deserialize, Serialize)]
+#[serde(rename_all = "camelCase")]
+struct Settings {
+    lan_mode: bool,
+    port: u16,
+    worker_domain: String,
+}
 
-// -- Colors (GitHub Dark inspired) ------------------------------------------
+impl Default for Settings {
+    fn default() -> Self {
+        Self {
+            lan_mode: false,
+            port: proxy::DEFAULT_PORT,
+            worker_domain: String::new(),
+        }
+    }
+}
 
-const BG: egui::Color32 = egui::Color32::from_rgb(13, 17, 23);
-const SURFACE: egui::Color32 = egui::Color32::from_rgb(22, 27, 34);
-const BORDER: egui::Color32 = egui::Color32::from_rgb(48, 54, 61);
-const ACCENT: egui::Color32 = egui::Color32::from_rgb(88, 166, 255);
-const GREEN: egui::Color32 = egui::Color32::from_rgb(63, 185, 80);
-const RED: egui::Color32 = egui::Color32::from_rgb(248, 81, 73);
-const TEXT: egui::Color32 = egui::Color32::from_rgb(230, 237, 243);
-const TEXT2: egui::Color32 = egui::Color32::from_rgb(139, 148, 158);
-const AD_BG: egui::Color32 = egui::Color32::from_rgb(17, 21, 28);
+#[derive(Clone, Serialize)]
+#[serde(rename_all = "camelCase")]
+struct LogLine {
+    timestamp: String,
+    message: String,
+    error: bool,
+}
 
-fn main() -> eframe::Result<()> {
-    eframe::run_native(
-        "TGLock",
-        eframe::NativeOptions {
-            viewport: egui::ViewportBuilder::default()
-                .with_inner_size([520.0, 620.0])
-                .with_min_inner_size([420.0, 500.0])
-                .with_title("TGLock"),
-            ..Default::default()
-        },
-        Box::new(|cc| {
-            apply_theme(&cc.egui_ctx);
-            Ok(Box::new(App::new()))
-        }),
+#[derive(Serialize)]
+#[serde(rename_all = "camelCase")]
+struct StatusSnapshot {
+    running: bool,
+    active_connections: u32,
+    tunnels: u32,
+    data_center: Option<u16>,
+    route: String,
+    failures: u32,
+    uptime_seconds: u64,
+    port: u16,
+    logs: Vec<LogLine>,
+}
+
+struct AppState {
+    stats: Arc<proxy::Stats>,
+    settings: Mutex<Settings>,
+    active_port: Mutex<u16>,
+    started_at: Mutex<Option<Instant>>,
+    logs: Arc<Mutex<Vec<LogLine>>>,
+    settings_path: PathBuf,
+}
+
+impl AppState {
+    fn new(settings_path: PathBuf) -> Self {
+        let settings = std::fs::read(&settings_path)
+            .ok()
+            .and_then(|contents| serde_json::from_slice(&contents).ok())
+            .unwrap_or_default();
+        Self {
+            stats: proxy::Stats::new(),
+            settings: Mutex::new(settings),
+            active_port: Mutex::new(proxy::DEFAULT_PORT),
+            started_at: Mutex::new(None),
+            logs: Arc::new(Mutex::new(Vec::new())),
+            settings_path,
+        }
+    }
+
+    fn log(&self, message: impl Into<String>, error: bool) {
+        let mut logs = self.logs.lock().unwrap();
+        logs.push(LogLine {
+            timestamp: current_time(),
+            message: message.into(),
+            error,
+        });
+        if logs.len() > 100 {
+            logs.remove(0);
+        }
+    }
+
+    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));
+        StatusSnapshot {
+            running: self.stats.running.load(Ordering::SeqCst),
+            active_connections: self.stats.active.load(Ordering::Relaxed),
+            tunnels: self.stats.ws.load(Ordering::Relaxed),
+            data_center: (data_center > 0).then_some(data_center),
+            route: route.to_owned(),
+            failures: self.stats.ws_failures.load(Ordering::Relaxed),
+            uptime_seconds: self
+                .started_at
+                .lock()
+                .unwrap()
+                .map_or(0, |started| started.elapsed().as_secs()),
+            port: *self.active_port.lock().unwrap(),
+            logs: self.logs.lock().unwrap().clone(),
+        }
+    }
+
+    fn persist_settings(&self, settings: &Settings) -> Result<(), String> {
+        if let Some(parent) = self.settings_path.parent() {
+            std::fs::create_dir_all(parent)
+                .map_err(|error| format!("Не удалось создать папку настроек: {error}"))?;
+        }
+        let contents = serde_json::to_vec_pretty(settings)
+            .map_err(|error| format!("Не удалось сохранить настройки: {error}"))?;
+        std::fs::write(&self.settings_path, contents)
+            .map_err(|error| format!("Не удалось сохранить настройки: {error}"))
+    }
+}
+
+fn current_time() -> String {
+    let seconds = SystemTime::now()
+        .duration_since(UNIX_EPOCH)
+        .unwrap_or_default()
+        .as_secs();
+    format!(
+        "{:02}:{:02}:{:02}",
+        (seconds / 3600) % 24,
+        (seconds / 60) % 60,
+        seconds % 60
     )
 }
 
-fn apply_theme(ctx: &egui::Context) {
-    let mut v = egui::Visuals::dark();
-    v.panel_fill = BG;
-    v.window_fill = SURFACE;
-    v.extreme_bg_color = BG;
-    v.faint_bg_color = SURFACE;
-    v.override_text_color = Some(TEXT);
-
-    v.widgets.noninteractive.bg_fill = SURFACE;
-    v.widgets.noninteractive.fg_stroke = egui::Stroke::new(1.0, TEXT2);
-    v.widgets.noninteractive.bg_stroke = egui::Stroke::new(1.0, BORDER);
-
-    v.widgets.inactive.bg_fill = egui::Color32::from_rgb(33, 38, 45);
-    v.widgets.inactive.fg_stroke = egui::Stroke::new(1.0, TEXT);
-    v.widgets.inactive.bg_stroke = egui::Stroke::new(1.0, BORDER);
-
-    v.widgets.hovered.bg_fill = egui::Color32::from_rgb(48, 54, 61);
-    v.widgets.hovered.fg_stroke = egui::Stroke::new(1.0, TEXT);
-
-    v.widgets.active.bg_fill = ACCENT;
-    v.widgets.active.fg_stroke = egui::Stroke::new(1.0, BG);
-
-    ctx.set_visuals(v);
+#[tauri::command]
+fn get_status(state: State<'_, AppState>) -> StatusSnapshot {
+    state.snapshot()
 }
 
-// -- Log --------------------------------------------------------------------
-
-#[derive(Clone)]
-struct LogLine {
-    ts: String,
-    msg: String,
-    err: bool,
+#[tauri::command]
+fn get_settings(state: State<'_, AppState>) -> Settings {
+    state.settings.lock().unwrap().clone()
 }
 
-fn now_ts() -> String {
-    let s = std::time::SystemTime::now()
-        .duration_since(std::time::UNIX_EPOCH)
-        .unwrap_or_default()
-        .as_secs();
-    format!("{:02}:{:02}:{:02}", (s / 3600) % 24, (s / 60) % 60, s % 60)
+#[tauri::command]
+fn save_settings(settings: Settings, state: State<'_, AppState>) -> Result<Settings, String> {
+    if state.stats.running.load(Ordering::SeqCst) {
+        return Err("Сначала выключите защиту".into());
+    }
+    if settings.port == 0 {
+        return Err("Порт должен быть от 1 до 65535".into());
+    }
+    state.persist_settings(&settings)?;
+    *state.settings.lock().unwrap() = settings.clone();
+    state.log("Настройки сохранены", false);
+    Ok(settings)
 }
 
-fn log(log: &Arc<Mutex<Vec<LogLine>>>, msg: &str, err: bool) {
-    log.lock().unwrap().push(LogLine {
-        ts: now_ts(),
-        msg: msg.into(),
-        err,
+#[tauri::command]
+fn start_proxy(state: State<'_, AppState>) -> Result<StatusSnapshot, String> {
+    if state.stats.running.load(Ordering::SeqCst) {
+        return Ok(state.snapshot());
+    }
+
+    let settings = state.settings.lock().unwrap().clone();
+    state.stats.set_worker_domain(&settings.worker_domain);
+    *state.active_port.lock().unwrap() = settings.port;
+    *state.started_at.lock().unwrap() = Some(Instant::now());
+    state.log("Запускаю защищённый маршрут…", false);
+
+    let listen = if settings.lan_mode {
+        ListenConfig::lan(settings.port)
+    } else {
+        ListenConfig::loopback(settings.port)
+    };
+
+    let stats = state.stats.clone();
+    let logs = state.logs.clone();
+    std::thread::spawn(move || {
+        let runtime = match tokio::runtime::Runtime::new() {
+            Ok(runtime) => runtime,
+            Err(error) => {
+                push_log(&logs, format!("Не удалось запустить сервис: {error}"), true);
+                return;
+            }
+        };
+        if let Err(error) = runtime.block_on(proxy::run(stats, listen)) {
+            push_log(&logs, format!("Ошибка подключения: {error}"), true);
+        }
+    });
+
+    std::thread::sleep(std::time::Duration::from_millis(220));
+    if !state.stats.running.load(Ordering::SeqCst) {
+        *state.started_at.lock().unwrap() = None;
+        return Err(state
+            .logs
+            .lock()
+            .unwrap()
+            .last()
+            .map(|line| line.message.clone())
+            .unwrap_or_else(|| "Не удалось запустить прокси".into()));
+    }
+
+    state.log(format!("Прокси запущен на {}", listen.addr), false);
+    let _ = open::that(listen.telegram_link(&state.stats.telegram_secret()));
+    state.log("Открываю подключение в Telegram…", false);
+    Ok(state.snapshot())
+}
+
+#[tauri::command]
+fn stop_proxy(state: State<'_, AppState>) -> StatusSnapshot {
+    state.stats.stop();
+    *state.started_at.lock().unwrap() = None;
+    state.log("Защита выключена", false);
+    state.snapshot()
+}
+
+fn push_log(logs: &Arc<Mutex<Vec<LogLine>>>, message: String, error: bool) {
+    logs.lock().unwrap().push(LogLine {
+        timestamp: current_time(),
+        message,
+        error,
     });
 }
 
-// -- App --------------------------------------------------------------------
+/// Environment variables that make the WebView render without a GPU.
+///
+/// The window is never created when 3D acceleration is unavailable: no
+/// monitor, the default Microsoft display driver, a virtual machine without
+/// 3D enabled (by-sonic/tglock#10, by-sonic/tglock#17). For a small status
+/// panel software rendering costs nothing noticeable, so preferring it is the
+/// safer default.
+///
+/// Values already present in the environment are never overwritten, and
+/// `TGLOCK_FORCE_GPU` disables the whole mechanism.
+fn software_rendering_vars(
+    force_gpu: bool,
+    is_set: impl Fn(&str) -> bool,
+) -> Vec<(&'static str, &'static str)> {
+    if force_gpu {
+        return Vec::new();
+    }
 
-struct App {
-    stats: Arc<proxy::Stats>,
-    log: Arc<Mutex<Vec<LogLine>>>,
-    started_at: Option<Instant>,
-    lan_mode: bool,
+    let candidates: &[(&str, &str)] = if cfg!(target_os = "windows") {
+        &[(
+            "WEBVIEW2_ADDITIONAL_BROWSER_ARGUMENTS",
+            "--disable-gpu --disable-gpu-compositing",
+        )]
+    } else if cfg!(target_os = "macos") {
+        // WebKit on macOS falls back to software rendering on its own.
+        &[]
+    } else {
+        &[
+            ("WEBKIT_DISABLE_COMPOSITING_MODE", "1"),
+            ("WEBKIT_DISABLE_DMABUF_RENDERER", "1"),
+        ]
+    };
+
+    candidates
+        .iter()
+        .filter(|(key, _)| !is_set(key))
+        .copied()
+        .collect()
 }
 
-impl App {
-    fn new() -> Self {
-        Self {
-            stats: proxy::Stats::new(),
-            log: Arc::new(Mutex::new(Vec::new())),
-            started_at: None,
-            lan_mode: false,
+fn prefer_software_rendering() {
+    let force_gpu = std::env::var_os("TGLOCK_FORCE_GPU").is_some();
+    for (key, value) in software_rendering_vars(force_gpu, |key| std::env::var_os(key).is_some()) {
+        std::env::set_var(key, value);
+    }
+}
+
+fn main() {
+    prefer_software_rendering();
+
+    tauri::Builder::default()
+        .setup(|app| {
+            let settings_path = app
+                .path()
+                .app_config_dir()
+                .map_err(|error| error.to_string())?
+                .join("settings.json");
+            app.manage(AppState::new(settings_path));
+            Ok(())
+        })
+        .invoke_handler(tauri::generate_handler![
+            get_status,
+            get_settings,
+            save_settings,
+            start_proxy,
+            stop_proxy
+        ])
+        .run(tauri::generate_context!())
+        .expect("failed to run TGLock");
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn software_rendering_is_requested_by_default() {
+        let vars = software_rendering_vars(false, |_| false);
+        if cfg!(target_os = "macos") {
+            assert!(vars.is_empty(), "macOS needs no override");
+        } else {
+            assert!(
+                !vars.is_empty(),
+                "a machine without 3D acceleration must still get a window"
+            );
         }
     }
 
-    fn running(&self) -> bool {
-        self.stats.running.load(Ordering::SeqCst)
+    #[test]
+    fn force_gpu_disables_the_override() {
+        assert!(software_rendering_vars(true, |_| false).is_empty());
     }
 
-    fn start(&mut self) {
-        if self.running() { return; }
-        self.started_at = Some(Instant::now());
-        let stats = self.stats.clone();
-        let lg = self.log.clone();
-        let lan = self.lan_mode;
-
-        log(&lg, "Запускаю прокси...", false);
-
-        std::thread::spawn(move || {
-            let rt = tokio::runtime::Runtime::new().unwrap();
-            let r = rt.block_on(proxy::run(stats, lan));
-            if let Err(e) = r {
-                log(&lg, &format!("Ошибка: {}", e), true);
-            }
-        });
-
-        std::thread::sleep(std::time::Duration::from_millis(250));
-        if self.running() {
-            let addr = if lan { "0.0.0.0" } else { "127.0.0.1" };
-            log(&self.log, &format!("SOCKS5 на {}:{}", addr, proxy::PORT), false);
-            if lan {
-                log(&self.log, "LAN-режим: другие устройства могут подключаться", false);
-            }
-        }
+    #[test]
+    fn an_operators_own_value_is_never_overwritten() {
+        assert!(software_rendering_vars(false, |_| true).is_empty());
     }
 
-    fn stop(&mut self) {
-        self.stats.running.store(false, Ordering::SeqCst);
-        self.started_at = None;
-        log(&self.log, "Остановлен", false);
-    }
-
-    fn uptime_str(&self) -> String {
-        match self.started_at {
-            Some(t) => {
-                let s = t.elapsed().as_secs();
-                format!("{:02}:{:02}:{:02}", s / 3600, (s / 60) % 60, s % 60)
-            }
-            None => "--:--:--".into(),
+    #[test]
+    fn windows_uses_webview2_arguments_and_linux_uses_webkit_ones() {
+        let keys: Vec<_> = software_rendering_vars(false, |_| false)
+            .into_iter()
+            .map(|(key, _)| key)
+            .collect();
+        if cfg!(target_os = "windows") {
+            assert_eq!(keys, ["WEBVIEW2_ADDITIONAL_BROWSER_ARGUMENTS"]);
+        } else if cfg!(target_os = "linux") {
+            assert_eq!(
+                keys,
+                [
+                    "WEBKIT_DISABLE_COMPOSITING_MODE",
+                    "WEBKIT_DISABLE_DMABUF_RENDERER"
+                ]
+            );
         }
     }
 }
-
-impl eframe::App for App {
-    fn update(&mut self, ctx: &egui::Context, _frame: &mut eframe::Frame) {
-        ctx.request_repaint_after(std::time::Duration::from_millis(300));
-
-        let on = self.running();
-        let active = self.stats.active.load(Ordering::Relaxed);
-        let total = self.stats.total.load(Ordering::Relaxed);
-        let ws = self.stats.ws.load(Ordering::Relaxed);
-        let dc = self.stats.last_dc.load(Ordering::Relaxed);
-
-        // === Ad bar (top) ===
-        egui::TopBottomPanel::top("ad").show(ctx, |ui| {
-            egui::Frame::new()
-                .fill(AD_BG)
-                .inner_margin(egui::Margin::symmetric(12, 6))
-                .show(ui, |ui| {
-                    ui.horizontal(|ui| {
-                        ui.colored_label(ACCENT, egui::RichText::new("by sonic VPN").size(12.0).strong());
-                        ui.colored_label(TEXT2, egui::RichText::new("Обход для всех приложений").size(11.0));
-                        ui.with_layout(egui::Layout::right_to_left(egui::Align::Center), |ui| {
-                            if ui.add(egui::Button::new(
-                                egui::RichText::new("@bysonicvpn_bot").size(11.0).strong().color(ACCENT)
-                            ).frame(false)).clicked() {
-                                let _ = open::that("https://t.me/bysonicvpn_bot");
-                            }
-                        });
-                    });
-                });
-        });
-
-        // === Log (bottom) ===
-        egui::TopBottomPanel::bottom("log")
-            .min_height(120.0)
-            .show(ctx, |ui| {
-                ui.add_space(4.0);
-                ui.colored_label(TEXT2, egui::RichText::new("LOG").size(11.0));
-                ui.separator();
-                egui::ScrollArea::vertical()
-                    .auto_shrink([false, false])
-                    .stick_to_bottom(true)
-                    .show(ui, |ui| {
-                        for e in self.log.lock().unwrap().iter() {
-                            let c = if e.err { RED } else { TEXT2 };
-                            ui.colored_label(c, egui::RichText::new(
-                                format!("{} {}", e.ts, e.msg)
-                            ).size(11.5).monospace());
-                        }
-                    });
-            });
-
-        // === Stats bar ===
-        egui::TopBottomPanel::bottom("stats").show(ctx, |ui| {
-            egui::Frame::new()
-                .fill(SURFACE)
-                .inner_margin(egui::Margin::symmetric(16, 8))
-                .show(ui, |ui| {
-                    ui.horizontal(|ui| {
-                        stat(ui, "Соединения", &active.to_string());
-                        ui.add_space(20.0);
-                        stat(ui, "WS-туннели", &ws.to_string());
-                        ui.add_space(20.0);
-                        stat(ui, "DC", &if dc > 0 { dc.to_string() } else { "—".into() });
-                        ui.add_space(20.0);
-                        stat(ui, "Всего", &total.to_string());
-                        ui.with_layout(egui::Layout::right_to_left(egui::Align::Center), |ui| {
-                            stat(ui, "Аптайм", &self.uptime_str());
-                        });
-                    });
-                });
-        });
-
-        // === Main ===
-        egui::CentralPanel::default().show(ctx, |ui| {
-            ui.vertical_centered(|ui| {
-                ui.add_space(30.0);
-
-                // Title
-                ui.colored_label(TEXT, egui::RichText::new("TGLock").size(32.0).strong());
-                ui.add_space(4.0);
-                ui.colored_label(TEXT2, egui::RichText::new("WebSocket-туннель для Telegram").size(13.0));
-
-                ui.add_space(24.0);
-
-                // Status indicator
-                let (dot_color, status_text) = if on {
-                    (GREEN, "Подключено")
-                } else {
-                    (egui::Color32::from_rgb(80, 80, 80), "Отключено")
-                };
-
-                ui.horizontal(|ui| {
-                    let center = ui.available_width() / 2.0 - 50.0;
-                    ui.add_space(center);
-                    let (r, _) = ui.allocate_exact_size(egui::vec2(10.0, 10.0), egui::Sense::hover());
-                    ui.painter().circle_filled(r.center(), 5.0, dot_color);
-                    ui.colored_label(
-                        if on { GREEN } else { TEXT2 },
-                        egui::RichText::new(status_text).size(14.0).strong(),
-                    );
-                });
-
-                ui.add_space(20.0);
-
-                // LAN toggle (only when stopped)
-                if !on {
-                    ui.horizontal(|ui| {
-                        let center = ui.available_width() / 2.0 - 90.0;
-                        ui.add_space(center);
-                        ui.checkbox(&mut self.lan_mode, "");
-                        ui.colored_label(TEXT2, egui::RichText::new("Локальная сеть").size(12.0));
-                        ui.colored_label(
-                            egui::Color32::from_rgb(80, 85, 95),
-                            egui::RichText::new("(0.0.0.0 — для всех устройств)").size(10.5),
-                        );
-                    });
-                    ui.add_space(8.0);
-                }
-
-                // Big button
-                if !on {
-                    let btn = ui.add_sized(
-                        [260.0, 52.0],
-                        egui::Button::new(
-                            egui::RichText::new("ПОДКЛЮЧИТЬ").size(18.0).strong().color(BG)
-                        ).fill(ACCENT).corner_radius(8.0),
-                    );
-                    if btn.clicked() {
-                        self.start();
-                    }
-                } else {
-                    let btn = ui.add_sized(
-                        [260.0, 52.0],
-                        egui::Button::new(
-                            egui::RichText::new("ОТКЛЮЧИТЬ").size(18.0).strong().color(TEXT)
-                        ).fill(egui::Color32::from_rgb(40, 45, 52)).corner_radius(8.0),
-                    );
-                    if btn.clicked() {
-                        self.stop();
-                    }
-                }
-
-                ui.add_space(24.0);
-
-                // Setup section
-                egui::Frame::new()
-                    .fill(SURFACE)
-                    .corner_radius(8.0)
-                    .inner_margin(16.0)
-                    .show(ui, |ui| {
-                        ui.set_width(360.0);
-
-                        ui.colored_label(TEXT, egui::RichText::new("Настройка Telegram").size(14.0).strong());
-                        ui.add_space(6.0);
-
-                        let server_addr = if self.lan_mode && on {
-                            local_ip().unwrap_or_else(|| "127.0.0.1".into())
-                        } else {
-                            "127.0.0.1".into()
-                        };
-
-                        if on {
-                            if ui.add(egui::Button::new(
-                                egui::RichText::new("Настроить автоматически").size(13.0).color(ACCENT)
-                            ).frame(false)).clicked() {
-                                let _ = open::that(format!("tg://socks?server={}&port={}", server_addr, proxy::PORT));
-                                log(&self.log, "Открываю настройку Telegram...", false);
-                            }
-                            ui.add_space(4.0);
-                        }
-
-                        ui.colored_label(TEXT2, egui::RichText::new("Настройки → Продвинутые → Тип соединения → SOCKS5").size(11.5));
-                        ui.add_space(4.0);
-
-                        egui::Grid::new("cfg").num_columns(2).spacing([12.0, 3.0]).show(ui, |ui| {
-                            ui.colored_label(TEXT2, "Сервер");
-                            ui.monospace(&server_addr);
-                            ui.end_row();
-                            ui.colored_label(TEXT2, "Порт");
-                            ui.monospace(format!("{}", proxy::PORT));
-                            ui.end_row();
-                        });
-                    });
-
-                ui.add_space(16.0);
-
-                // How it works (compact)
-                ui.colored_label(TEXT2, egui::RichText::new(
-                    "Трафик Telegram → SOCKS5 → WSS → web.telegram.org → DC"
-                ).size(11.0));
-                ui.colored_label(TEXT2, egui::RichText::new(
-                    "Провайдер видит обычный HTTPS. Остальной трафик не затрагивается."
-                ).size(11.0));
-            });
-        });
-    }
-}
-
-fn stat(ui: &mut egui::Ui, label: &str, value: &str) {
-    ui.vertical(|ui| {
-        ui.colored_label(TEXT2, egui::RichText::new(label).size(10.0));
-        ui.colored_label(TEXT, egui::RichText::new(value).size(13.0).strong().monospace());
-    });
-}
-
-fn local_ip() -> Option<String> {
-    let socket = std::net::UdpSocket::bind("0.0.0.0:0").ok()?;
-    socket.connect("8.8.8.8:80").ok()?;
-    Some(socket.local_addr().ok()?.ip().to_string())
-}

src/mtproto.rs

@@ -0,0 +1,574 @@
+use aes::Aes256;
+use cipher::{KeyIvInit, StreamCipher};
+use rand::{rngs::OsRng, RngCore};
+use sha2::{Digest, Sha256};
+use std::path::Path;
+#[cfg(not(test))]
+use std::path::PathBuf;
+
+type AesCtr = ctr::Ctr128BE<Aes256>;
+
+const INIT_LEN: usize = 64;
+const KEY_START: usize = 8;
+const KEY_END: usize = 40;
+const IV_END: usize = 56;
+const TAG_START: usize = 56;
+const DC_START: usize = 60;
+
+const ABRIDGED: [u8; 4] = [0xef; 4];
+const INTERMEDIATE: [u8; 4] = [0xee; 4];
+const PADDED_INTERMEDIATE: [u8; 4] = [0xdd; 4];
+
+pub struct ClientInit {
+    pub dc: u16,
+    pub media: bool,
+    pub relay_init: [u8; INIT_LEN],
+    pub crypto: CryptoContext,
+}
+
+pub struct CryptoContext {
+    client_decrypt: AesCtr,
+    client_encrypt: AesCtr,
+    telegram_encrypt: AesCtr,
+    telegram_decrypt: AesCtr,
+}
+
+impl CryptoContext {
+    pub fn client_to_telegram(&mut self, data: &mut [u8]) {
+        self.client_decrypt.apply_keystream(data);
+        self.telegram_encrypt.apply_keystream(data);
+    }
+
+    pub fn telegram_to_client(&mut self, data: &mut [u8]) {
+        self.telegram_decrypt.apply_keystream(data);
+        self.client_encrypt.apply_keystream(data);
+    }
+}
+
+pub fn generate_secret() -> [u8; 16] {
+    let mut secret = [0; 16];
+    OsRng.fill_bytes(&mut secret);
+    secret
+}
+
+/// Reuse the secret stored at `path`, creating it if it is missing or unusable.
+///
+/// A daemon needs this: the secret is half of the `tg://proxy` link, so a
+/// service that invents a new one on every restart silently invalidates every
+/// client that was already configured.
+pub fn load_or_create_secret_at(path: &Path) -> [u8; 16] {
+    if let Ok(value) = std::fs::read_to_string(path) {
+        if let Some(secret) = parse_secret_hex(value.trim()) {
+            return secret;
+        }
+    }
+
+    let secret = generate_secret();
+    if let Some(parent) = path.parent() {
+        let _ = std::fs::create_dir_all(parent);
+    }
+    write_secret_file(path, &secret_hex(&secret));
+    secret
+}
+
+#[cfg(not(test))]
+pub fn load_or_create_secret() -> [u8; 16] {
+    match secret_path() {
+        Some(path) => load_or_create_secret_at(&path),
+        None => generate_secret(),
+    }
+}
+
+#[cfg(not(test))]
+fn secret_path() -> Option<PathBuf> {
+    #[cfg(target_os = "windows")]
+    {
+        std::env::var_os("APPDATA")
+            .map(PathBuf::from)
+            .map(|path| path.join("TGLock").join("secret"))
+    }
+    #[cfg(target_os = "macos")]
+    {
+        std::env::var_os("HOME")
+            .map(PathBuf::from)
+            .map(|path| path.join("Library/Application Support/TGLock/secret"))
+    }
+    #[cfg(all(unix, not(target_os = "macos")))]
+    {
+        if let Some(path) = std::env::var_os("XDG_CONFIG_HOME") {
+            return Some(PathBuf::from(path).join("tglock").join("secret"));
+        }
+        std::env::var_os("HOME")
+            .map(PathBuf::from)
+            .map(|path| path.join(".config/tglock/secret"))
+    }
+}
+
+#[cfg(unix)]
+fn write_secret_file(path: &Path, value: &str) {
+    use std::io::Write;
+    use std::os::unix::fs::OpenOptionsExt;
+    if let Ok(mut file) = std::fs::OpenOptions::new()
+        .create(true)
+        .truncate(true)
+        .write(true)
+        .mode(0o600)
+        .open(path)
+    {
+        let _ = file.write_all(value.as_bytes());
+    }
+}
+
+#[cfg(not(unix))]
+fn write_secret_file(path: &Path, value: &str) {
+    let _ = std::fs::write(path, value);
+}
+
+pub fn secret_hex(secret: &[u8; 16]) -> String {
+    let mut output = String::with_capacity(32);
+    for byte in secret {
+        use std::fmt::Write;
+        let _ = write!(output, "{:02x}", byte);
+    }
+    output
+}
+
+/// Разобрать секрет, записанный человеком.
+///
+/// Принимает и 32 hex-символа, и форму с префиксом `dd` — именно так секрет
+/// выглядит в ссылке `tg://proxy`, откуда его и копируют.
+pub fn parse_secret(value: &str) -> Option<[u8; 16]> {
+    let trimmed = value.trim();
+    let hex = trimmed
+        .strip_prefix("dd")
+        .filter(|rest| rest.len() == 32)
+        .unwrap_or(trimmed);
+    parse_secret_hex(hex)
+}
+
+fn parse_secret_hex(value: &str) -> Option<[u8; 16]> {
+    if value.len() != 32 {
+        return None;
+    }
+    let mut secret = [0; 16];
+    for (index, byte) in secret.iter_mut().enumerate() {
+        *byte = u8::from_str_radix(&value[index * 2..index * 2 + 2], 16).ok()?;
+    }
+    Some(secret)
+}
+
+pub fn telegram_secret(secret: &[u8; 16]) -> String {
+    format!("dd{}", secret_hex(secret))
+}
+
+pub fn parse_client_init(init: &[u8; INIT_LEN], secret: &[u8; 16]) -> Option<ClientInit> {
+    let client_dec_key = secret_key(&init[KEY_START..KEY_END], secret);
+    let client_dec_iv: [u8; 16] = init[KEY_END..IV_END].try_into().ok()?;
+    let mut client_decrypt = AesCtr::new((&client_dec_key).into(), (&client_dec_iv).into());
+
+    let mut decrypted = *init;
+    client_decrypt.apply_keystream(&mut decrypted);
+    let protocol_tag: [u8; 4] = decrypted[TAG_START..DC_START].try_into().ok()?;
+    if !matches!(protocol_tag, ABRIDGED | INTERMEDIATE | PADDED_INTERMEDIATE) {
+        return None;
+    }
+
+    let dc_index = i16::from_le_bytes([decrypted[DC_START], decrypted[DC_START + 1]]);
+    let dc = dc_index.unsigned_abs();
+    if !matches!(dc, 1..=5 | 203) {
+        return None;
+    }
+
+    let relay_init = generate_relay_init(protocol_tag, dc_index);
+    let crypto = build_crypto_context(init, secret, &relay_init)?;
+    Some(ClientInit {
+        dc,
+        media: dc_index < 0,
+        relay_init,
+        crypto,
+    })
+}
+
+fn secret_key(prekey: &[u8], secret: &[u8; 16]) -> [u8; 32] {
+    let mut hash = Sha256::new();
+    hash.update(prekey);
+    hash.update(secret);
+    hash.finalize().into()
+}
+
+fn generate_relay_init(protocol_tag: [u8; 4], dc_index: i16) -> [u8; INIT_LEN] {
+    loop {
+        let mut init = [0; INIT_LEN];
+        OsRng.fill_bytes(&mut init);
+        if is_reserved_init(&init) {
+            continue;
+        }
+
+        let key: [u8; 32] = init[KEY_START..KEY_END].try_into().unwrap();
+        let iv: [u8; 16] = init[KEY_END..IV_END].try_into().unwrap();
+        let mut cipher = AesCtr::new((&key).into(), (&iv).into());
+        let mut encrypted = init;
+        cipher.apply_keystream(&mut encrypted);
+
+        let mut tail = [0; 8];
+        tail[..4].copy_from_slice(&protocol_tag);
+        tail[4..6].copy_from_slice(&dc_index.to_le_bytes());
+        OsRng.fill_bytes(&mut tail[6..]);
+        for index in 0..8 {
+            init[TAG_START + index] ^= tail[index] ^ encrypted[TAG_START + index];
+        }
+        return init;
+    }
+}
+
+fn is_reserved_init(init: &[u8; INIT_LEN]) -> bool {
+    init[0] == 0xef
+        || &init[..4] == b"HEAD"
+        || &init[..4] == b"POST"
+        || &init[..4] == b"GET "
+        || init[..4] == [0xee; 4]
+        || init[..4] == [0xdd; 4]
+        || init[..4] == [0x16, 0x03, 0x01, 0x02]
+        || init[4..8] == [0; 4]
+}
+
+fn build_crypto_context(
+    client_init: &[u8; INIT_LEN],
+    secret: &[u8; 16],
+    relay_init: &[u8; INIT_LEN],
+) -> Option<CryptoContext> {
+    let client_dec_key = secret_key(&client_init[KEY_START..KEY_END], secret);
+    let client_dec_iv: [u8; 16] = client_init[KEY_END..IV_END].try_into().ok()?;
+    let mut client_decrypt = AesCtr::new((&client_dec_key).into(), (&client_dec_iv).into());
+    client_decrypt.apply_keystream(&mut [0; INIT_LEN]);
+
+    let reversed_client: Vec<_> = client_init[KEY_START..IV_END]
+        .iter()
+        .rev()
+        .copied()
+        .collect();
+    let client_enc_key = secret_key(&reversed_client[..32], secret);
+    let client_enc_iv: [u8; 16] = reversed_client[32..].try_into().ok()?;
+    let client_encrypt = AesCtr::new((&client_enc_key).into(), (&client_enc_iv).into());
+
+    let relay_enc_key: [u8; 32] = relay_init[KEY_START..KEY_END].try_into().ok()?;
+    let relay_enc_iv: [u8; 16] = relay_init[KEY_END..IV_END].try_into().ok()?;
+    let mut telegram_encrypt = AesCtr::new((&relay_enc_key).into(), (&relay_enc_iv).into());
+    telegram_encrypt.apply_keystream(&mut [0; INIT_LEN]);
+
+    let reversed_relay: Vec<_> = relay_init[KEY_START..IV_END]
+        .iter()
+        .rev()
+        .copied()
+        .collect();
+    let relay_dec_key: [u8; 32] = reversed_relay[..32].try_into().ok()?;
+    let relay_dec_iv: [u8; 16] = reversed_relay[32..].try_into().ok()?;
+    let telegram_decrypt = AesCtr::new((&relay_dec_key).into(), (&relay_dec_iv).into());
+
+    Some(CryptoContext {
+        client_decrypt,
+        client_encrypt,
+        telegram_encrypt,
+        telegram_decrypt,
+    })
+}
+
+#[cfg(test)]
+pub(crate) fn test_client_init(secret: &[u8; 16], dc_index: i16) -> [u8; INIT_LEN] {
+    tests::generate_client_init(secret, PADDED_INTERMEDIATE, dc_index)
+}
+
+/// One end of an obfuscated2 stream, built the way the real peer builds it.
+///
+/// Lets tests assert on the bytes the peer actually observes rather than on the
+/// proxy's own view of them, so a mistake that is symmetric inside
+/// [`CryptoContext`] still fails the test.
+#[cfg(test)]
+pub(crate) struct TestPeer {
+    encrypt: AesCtr,
+    decrypt: AesCtr,
+}
+
+#[cfg(test)]
+impl TestPeer {
+    pub(crate) fn encrypt(&mut self, data: &mut [u8]) {
+        self.encrypt.apply_keystream(data);
+    }
+
+    pub(crate) fn decrypt(&mut self, data: &mut [u8]) {
+        self.decrypt.apply_keystream(data);
+    }
+}
+
+/// The Telegram client: its keys come from the init it sent, salted with the
+/// shared secret.
+#[cfg(test)]
+pub(crate) fn test_client_peer(init: &[u8; INIT_LEN], secret: &[u8; 16]) -> TestPeer {
+    let key = secret_key(&init[KEY_START..KEY_END], secret);
+    let iv: [u8; 16] = init[KEY_END..IV_END].try_into().unwrap();
+    let mut encrypt = AesCtr::new((&key).into(), (&iv).into());
+    encrypt.apply_keystream(&mut [0; INIT_LEN]);
+
+    let reversed: Vec<u8> = init[KEY_START..IV_END].iter().rev().copied().collect();
+    let decrypt_key = secret_key(&reversed[..32], secret);
+    let decrypt_iv: [u8; 16] = reversed[32..].try_into().unwrap();
+    let decrypt = AesCtr::new((&decrypt_key).into(), (&decrypt_iv).into());
+
+    TestPeer { encrypt, decrypt }
+}
+
+/// The Telegram relay: no shared secret, keys come straight from the init the
+/// proxy generated for it.
+#[cfg(test)]
+pub(crate) fn test_relay_peer(relay_init: &[u8; INIT_LEN]) -> TestPeer {
+    let key: [u8; 32] = relay_init[KEY_START..KEY_END].try_into().unwrap();
+    let iv: [u8; 16] = relay_init[KEY_END..IV_END].try_into().unwrap();
+    let mut decrypt = AesCtr::new((&key).into(), (&iv).into());
+    decrypt.apply_keystream(&mut [0; INIT_LEN]);
+
+    let reversed: Vec<u8> = relay_init[KEY_START..IV_END]
+        .iter()
+        .rev()
+        .copied()
+        .collect();
+    let encrypt_key: [u8; 32] = reversed[..32].try_into().unwrap();
+    let encrypt_iv: [u8; 16] = reversed[32..].try_into().unwrap();
+    let encrypt = AesCtr::new((&encrypt_key).into(), (&encrypt_iv).into());
+
+    TestPeer { encrypt, decrypt }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    pub(super) fn generate_client_init(
+        secret: &[u8; 16],
+        protocol_tag: [u8; 4],
+        dc_index: i16,
+    ) -> [u8; INIT_LEN] {
+        let mut init = generate_relay_init(protocol_tag, dc_index);
+        let key = secret_key(&init[KEY_START..KEY_END], secret);
+        let iv: [u8; 16] = init[KEY_END..IV_END].try_into().unwrap();
+        let mut cipher = AesCtr::new((&key).into(), (&iv).into());
+        let mut encrypted = init;
+        cipher.apply_keystream(&mut encrypted);
+
+        let mut tail = [0; 8];
+        tail[..4].copy_from_slice(&protocol_tag);
+        tail[4..6].copy_from_slice(&dc_index.to_le_bytes());
+        tail[6..].copy_from_slice(&[17, 23]);
+        for index in 0..8 {
+            init[TAG_START + index] ^= tail[index] ^ encrypted[TAG_START + index];
+        }
+        init
+    }
+
+    #[test]
+    fn parses_secret_protected_media_init() {
+        let secret = [42; 16];
+        let init = generate_client_init(&secret, PADDED_INTERMEDIATE, -4);
+        let parsed = parse_client_init(&init, &secret).unwrap();
+        assert_eq!(parsed.dc, 4);
+        assert!(parsed.media);
+    }
+
+    #[test]
+    fn rejects_wrong_secret() {
+        let init = generate_client_init(&[42; 16], INTERMEDIATE, 2);
+        assert!(parse_client_init(&init, &[7; 16]).is_none());
+    }
+
+    #[test]
+    fn telegram_link_secret_has_padded_intermediate_prefix() {
+        assert_eq!(
+            telegram_secret(&[0xab; 16]),
+            "ddabababababababababababababababab"
+        );
+    }
+
+    #[test]
+    fn accepts_every_supported_protocol_tag() {
+        let secret = [7; 16];
+        for tag in [ABRIDGED, INTERMEDIATE, PADDED_INTERMEDIATE] {
+            let init = generate_client_init(&secret, tag, 2);
+            let parsed = parse_client_init(&init, &secret)
+                .unwrap_or_else(|| panic!("tag {tag:02x?} must be accepted"));
+            assert_eq!(parsed.dc, 2);
+            assert!(!parsed.media);
+        }
+    }
+
+    #[test]
+    fn relay_init_carries_the_clients_protocol_tag_and_dc() {
+        let secret = [3; 16];
+        for (tag, dc_index) in [
+            (ABRIDGED, 1_i16),
+            (INTERMEDIATE, -5),
+            (PADDED_INTERMEDIATE, 203),
+        ] {
+            let init = generate_client_init(&secret, tag, dc_index);
+            let parsed = parse_client_init(&init, &secret).unwrap();
+
+            // The relay init is freshly generated, never the client's bytes.
+            assert_ne!(parsed.relay_init, init);
+
+            // Decoding the relay init the way Telegram does must recover the
+            // same protocol and data centre the client asked for.
+            let key: [u8; 32] = parsed.relay_init[KEY_START..KEY_END].try_into().unwrap();
+            let iv: [u8; 16] = parsed.relay_init[KEY_END..IV_END].try_into().unwrap();
+            let mut cipher = AesCtr::new((&key).into(), (&iv).into());
+            let mut decoded = parsed.relay_init;
+            cipher.apply_keystream(&mut decoded);
+
+            assert_eq!(decoded[TAG_START..DC_START], tag);
+            assert_eq!(
+                i16::from_le_bytes([decoded[DC_START], decoded[DC_START + 1]]),
+                dc_index
+            );
+        }
+    }
+
+    #[test]
+    fn rejects_data_centers_outside_the_known_range() {
+        let secret = [11; 16];
+        for dc_index in [0_i16, 6, -6, 204, -204, 1000] {
+            let init = generate_client_init(&secret, INTERMEDIATE, dc_index);
+            assert!(
+                parse_client_init(&init, &secret).is_none(),
+                "DC index {dc_index} must be rejected"
+            );
+        }
+    }
+
+    #[test]
+    fn negative_index_marks_media_and_keeps_the_data_center() {
+        let secret = [13; 16];
+        for dc in [1_u16, 2, 3, 4, 5, 203] {
+            let index = -(dc as i16);
+            let parsed =
+                parse_client_init(&generate_client_init(&secret, ABRIDGED, index), &secret)
+                    .unwrap();
+            assert_eq!(parsed.dc, dc);
+            assert!(parsed.media);
+
+            let parsed =
+                parse_client_init(&generate_client_init(&secret, ABRIDGED, dc as i16), &secret)
+                    .unwrap();
+            assert_eq!(parsed.dc, dc);
+            assert!(!parsed.media);
+        }
+    }
+
+    #[test]
+    fn plaintext_survives_the_trip_to_the_relay_and_back() {
+        let secret = [42; 16];
+        let init = generate_client_init(&secret, ABRIDGED, 2);
+        let mut parsed = parse_client_init(&init, &secret).unwrap();
+        let mut client = test_client_peer(&init, &secret);
+        let mut relay = test_relay_peer(&parsed.relay_init);
+
+        let request = b"exactly what Telegram must receive".to_vec();
+        let mut wire = request.clone();
+        client.encrypt(&mut wire);
+        assert_ne!(wire, request, "the wire must not carry plaintext");
+        parsed.crypto.client_to_telegram(&mut wire);
+        assert_ne!(wire, request, "the upstream wire must not carry plaintext");
+        relay.decrypt(&mut wire);
+        assert_eq!(wire, request);
+
+        let response = b"exactly what the client must receive".to_vec();
+        let mut wire = response.clone();
+        relay.encrypt(&mut wire);
+        parsed.crypto.telegram_to_client(&mut wire);
+        client.decrypt(&mut wire);
+        assert_eq!(wire, response);
+    }
+
+    #[test]
+    fn keystream_advances_across_chunks() {
+        let secret = [5; 16];
+        let init = generate_client_init(&secret, INTERMEDIATE, 3);
+        let mut parsed = parse_client_init(&init, &secret).unwrap();
+        let mut client = test_client_peer(&init, &secret);
+        let mut relay = test_relay_peer(&parsed.relay_init);
+
+        // A stream cipher is only correct if both ends stay in lockstep across
+        // arbitrary chunk boundaries, which is how TCP actually delivers data.
+        let chunks: [&[u8]; 4] = [b"one", b"", b"the third chunk is longer", b"4"];
+        for chunk in chunks {
+            let mut wire = chunk.to_vec();
+            client.encrypt(&mut wire);
+            parsed.crypto.client_to_telegram(&mut wire);
+            relay.decrypt(&mut wire);
+            assert_eq!(wire, chunk);
+        }
+    }
+
+    #[test]
+    fn reserved_prefixes_never_leave_the_generator() {
+        // A relay init that starts with an HTTP verb or a protocol tag would be
+        // misread by Telegram's frontend.
+        for _ in 0..2_000 {
+            assert!(!is_reserved_init(&generate_relay_init(ABRIDGED, 2)));
+        }
+    }
+
+    #[test]
+    fn accepts_a_secret_copied_from_a_tg_link() {
+        let expected = [
+            0x00, 0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77, 0x88, 0x99, 0xaa, 0xbb, 0xcc, 0xdd,
+            0xee, 0xff,
+        ];
+        // Обе формы: как в файле и как в ссылке tg://proxy.
+        assert_eq!(
+            parse_secret("00112233445566778899aabbccddeeff"),
+            Some(expected)
+        );
+        assert_eq!(
+            parse_secret("dd00112233445566778899aabbccddeeff"),
+            Some(expected)
+        );
+        // Пробелы по краям — обычное дело при копировании.
+        assert_eq!(
+            parse_secret("  dd00112233445566778899aabbccddeeff\n"),
+            Some(expected)
+        );
+        // Секрет, который сам начинается с dd и уже имеет полную длину, не
+        // должен потерять первый байт: префикс снимается только если после него
+        // остаётся ровно 32 символа.
+        assert_eq!(
+            parse_secret("dd112233445566778899aabbccddeeff"),
+            Some([
+                0xdd, 0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77, 0x88, 0x99, 0xaa, 0xbb, 0xcc, 0xdd,
+                0xee, 0xff,
+            ])
+        );
+    }
+
+    #[test]
+    fn rejects_malformed_secrets() {
+        for bad in [
+            "",
+            "dd",
+            "слишком коротко",
+            "00112233445566778899aabbccddee",     // 30 символов
+            "00112233445566778899aabbccddeeffff", // 34 символа
+            "zz112233445566778899aabbccddeeff",   // не hex
+        ] {
+            assert!(parse_secret(bad).is_none(), "{bad:?} должен быть отвергнут");
+        }
+    }
+
+    #[test]
+    fn parses_persisted_secret() {
+        assert_eq!(
+            parse_secret_hex("00112233445566778899aabbccddeeff"),
+            Some([
+                0x00, 0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77, 0x88, 0x99, 0xaa, 0xbb, 0xcc, 0xdd,
+                0xee, 0xff,
+            ])
+        );
+        assert_eq!(parse_secret_hex("not-a-secret"), None);
+    }
+}

src/transport.rs

@@ -0,0 +1,729 @@
+use std::collections::HashMap;
+use std::sync::Mutex;
+use std::time::{Duration, Instant};
+
+use tokio::net::TcpStream;
+use tokio_tungstenite::tungstenite::client::IntoClientRequest;
+use tokio_tungstenite::{MaybeTlsStream, WebSocketStream};
+
+const CONNECT_TIMEOUT: Duration = Duration::from_secs(4);
+const FAILURE_BACKOFF_INITIAL: Duration = Duration::from_secs(30);
+const FAILURE_BACKOFF_MAX: Duration = Duration::from_secs(30 * 60);
+const HTTPS_PORT: u16 = 443;
+
+pub type TelegramWebSocket = WebSocketStream<MaybeTlsStream<TcpStream>>;
+
+#[derive(Clone, Copy, Debug, Eq, Hash, PartialEq)]
+pub enum RouteKind {
+    TelegramIp,
+    AlternateTelegramIp,
+    SystemDns,
+    CloudflareWorker,
+}
+
+impl RouteKind {
+    pub fn ui_code(self) -> u8 {
+        match self {
+            Self::TelegramIp => 1,
+            Self::AlternateTelegramIp => 2,
+            Self::SystemDns => 3,
+            Self::CloudflareWorker => 4,
+        }
+    }
+
+    pub fn from_ui_code(code: u8) -> Option<Self> {
+        match code {
+            1 => Some(Self::TelegramIp),
+            2 => Some(Self::AlternateTelegramIp),
+            3 => Some(Self::SystemDns),
+            4 => Some(Self::CloudflareWorker),
+            _ => None,
+        }
+    }
+
+    /// Human-readable name of the route, shown by both frontends.
+    pub fn label(self) -> &'static str {
+        match self {
+            Self::TelegramIp => "Telegram IP",
+            Self::AlternateTelegramIp => "Запасной Telegram IP",
+            Self::SystemDns => "Системный DNS",
+            Self::CloudflareWorker => "Cloudflare Worker",
+        }
+    }
+}
+
+/// Label for a route code as stored in `Stats::last_route`.
+///
+/// Code `0` means no tunnel has been established yet, which must never be
+/// reported as a working route.
+pub fn route_label(ui_code: u8) -> &'static str {
+    RouteKind::from_ui_code(ui_code).map_or("Маршрут ещё не выбран", RouteKind::label)
+}
+
+#[derive(Clone, Debug, Eq, Hash, PartialEq)]
+pub struct Route {
+    pub connect_host: String,
+    pub websocket_host: String,
+    pub path: String,
+    pub kind: RouteKind,
+    /// TCP port to dial. Always 443 for Telegram and for Cloudflare Workers.
+    pub port: u16,
+    /// Wrap the connection in TLS. Always true outside tests.
+    pub secure: bool,
+}
+
+impl Route {
+    /// A production route: TLS on 443.
+    fn https(connect_host: String, websocket_host: String, path: String, kind: RouteKind) -> Self {
+        Self {
+            connect_host,
+            websocket_host,
+            path,
+            kind,
+            port: HTTPS_PORT,
+            secure: true,
+        }
+    }
+}
+
+#[derive(Clone, Debug)]
+pub struct ConnectedRoute {
+    pub route: Route,
+}
+
+#[derive(Clone, Copy, Debug, Eq, Hash, PartialEq)]
+struct DcKey {
+    dc: u16,
+    media: bool,
+}
+
+#[derive(Clone, Copy, Debug)]
+struct RouteHealth {
+    failures: u32,
+    retry_at: Instant,
+}
+
+#[derive(Default)]
+struct HealthState {
+    routes: HashMap<Route, RouteHealth>,
+    preferred: HashMap<DcKey, Route>,
+}
+
+#[derive(Default)]
+pub struct TransportEngine {
+    health: Mutex<HealthState>,
+    worker_domains: Mutex<Vec<String>>,
+    #[cfg(test)]
+    forced_routes: Mutex<Vec<Route>>,
+}
+
+#[cfg(test)]
+impl TransportEngine {
+    /// Point every data centre at a local plaintext WebSocket server so the
+    /// whole tunnel can be exercised without reaching Telegram.
+    pub(crate) fn force_local_route(&self, port: u16) {
+        self.force_local_route_with(port, RouteKind::TelegramIp, "/apiws".to_owned());
+    }
+
+    pub(crate) fn force_local_route_with(&self, port: u16, kind: RouteKind, path: String) {
+        *self.forced_routes.lock().unwrap() = vec![Route {
+            connect_host: "127.0.0.1".to_owned(),
+            websocket_host: format!("127.0.0.1:{}", port),
+            path,
+            kind,
+            port,
+            secure: false,
+        }];
+    }
+}
+
+impl TransportEngine {
+    pub fn new() -> Self {
+        Self::default()
+    }
+
+    pub fn set_worker_domains(&self, domains: &[String]) {
+        let mut normalized = Vec::new();
+        for domain in domains {
+            let domain = domain.trim().to_ascii_lowercase();
+            if valid_domain(&domain) && !normalized.contains(&domain) {
+                normalized.push(domain);
+            }
+        }
+        *self.worker_domains.lock().unwrap() = normalized;
+    }
+
+    pub async fn connect(
+        &self,
+        dc: u16,
+        media: bool,
+    ) -> Result<(TelegramWebSocket, ConnectedRoute), String> {
+        let key = DcKey { dc, media };
+        let candidates = self.ordered_candidates(key);
+        let mut errors = Vec::new();
+
+        for route in candidates {
+            match connect_route(&route).await {
+                Ok(websocket) => {
+                    self.record_success(key, &route);
+                    return Ok((websocket, ConnectedRoute { route }));
+                }
+                Err(error) => {
+                    self.record_failure(&route);
+                    errors.push(format!(
+                        "{} via {}: {}",
+                        route.websocket_host, route.connect_host, error
+                    ));
+                }
+            }
+        }
+
+        Err(format!(
+            "all Telegram routes for DC{}{} failed: {}",
+            dc,
+            if media { " media" } else { "" },
+            errors.join("; ")
+        ))
+    }
+
+    fn ordered_candidates(&self, key: DcKey) -> Vec<Route> {
+        let now = Instant::now();
+        let all_routes = self.routes_for_key(key);
+        let health = self.health.lock().unwrap();
+        let preferred = health.preferred.get(&key);
+        let mut candidates: Vec<_> = all_routes
+            .iter()
+            .filter(|route| {
+                health
+                    .routes
+                    .get(route)
+                    .is_none_or(|route_health| route_health.retry_at <= now)
+            })
+            .cloned()
+            .collect();
+
+        candidates.sort_by_key(|route| {
+            let preferred_rank = u8::from(preferred != Some(route));
+            let kind_rank = match route.kind {
+                RouteKind::TelegramIp => 0,
+                RouteKind::AlternateTelegramIp => 1,
+                RouteKind::SystemDns => 2,
+                RouteKind::CloudflareWorker => 3,
+            };
+            (preferred_rank, kind_rank)
+        });
+
+        // If every route is cooling down, retry the one that becomes available first.
+        if candidates.is_empty() {
+            if let Some((route, _)) = health
+                .routes
+                .iter()
+                .filter(|(route, _)| all_routes.contains(route))
+                .min_by_key(|(_, route_health)| route_health.retry_at)
+            {
+                candidates.push(route.clone());
+            }
+        }
+        candidates
+    }
+
+    fn routes_for_key(&self, key: DcKey) -> Vec<Route> {
+        #[cfg(test)]
+        {
+            let forced = self.forced_routes.lock().unwrap();
+            if !forced.is_empty() {
+                return forced.clone();
+            }
+        }
+
+        let mut routes = routes_for_dc(key.dc, key.media);
+        let Some(path) = worker_path(key.dc) else {
+            return routes;
+        };
+        for domain in self.worker_domains.lock().unwrap().iter() {
+            let path = path.clone();
+            routes.push(Route::https(
+                domain.clone(),
+                domain.clone(),
+                path,
+                RouteKind::CloudflareWorker,
+            ));
+        }
+        routes
+    }
+
+    fn record_success(&self, key: DcKey, route: &Route) {
+        let mut health = self.health.lock().unwrap();
+        health.routes.remove(route);
+        health.preferred.insert(key, route.clone());
+    }
+
+    fn record_failure(&self, route: &Route) {
+        let mut health = self.health.lock().unwrap();
+        let failures = health
+            .routes
+            .get(route)
+            .map_or(1, |route_health| route_health.failures.saturating_add(1));
+        let exponent = failures.saturating_sub(1).min(6);
+        let delay = FAILURE_BACKOFF_INITIAL
+            .saturating_mul(2_u32.pow(exponent))
+            .min(FAILURE_BACKOFF_MAX);
+        health.routes.insert(
+            route.clone(),
+            RouteHealth {
+                failures,
+                retry_at: Instant::now() + delay,
+            },
+        );
+    }
+}
+
+/// Path a user's Cloudflare Worker must serve for the given data centre.
+///
+/// This is the contract documented in `docs/CLOUDFLARE_WORKER.md`; both the
+/// route builder and the tests derive the path from here so the documentation
+/// cannot drift away from what the client actually requests.
+pub(crate) fn worker_path(dc: u16) -> Option<String> {
+    let destination = telegram_ips(dc).first()?;
+    Some(format!("/apiws?dst={}&dc={}", destination, dc))
+}
+
+/// Every address a Worker may be asked to reach, so a deployment can refuse
+/// anything else instead of becoming an open TCP proxy.
+pub fn worker_allowed_destinations() -> Vec<&'static str> {
+    let mut all: Vec<_> = [1, 2, 3, 4, 5, 203]
+        .into_iter()
+        .flat_map(|dc| telegram_ips(dc).iter().copied())
+        .collect();
+    all.sort_unstable();
+    all.dedup();
+    all
+}
+
+fn canonical_dc(dc: u16) -> u16 {
+    if dc == 203 {
+        2
+    } else {
+        dc
+    }
+}
+
+fn telegram_ips(dc: u16) -> &'static [&'static str] {
+    match dc {
+        1 => &["149.154.175.50"],
+        2 => &["149.154.167.51", "149.154.167.220"],
+        3 => &["149.154.175.100"],
+        4 => &["149.154.167.91", "149.154.167.220"],
+        5 => &["149.154.171.5"],
+        203 => &["91.105.192.100"],
+        _ => &[],
+    }
+}
+
+pub fn routes_for_dc(dc: u16, media: bool) -> Vec<Route> {
+    let websocket_dc = canonical_dc(dc);
+    let primary = format!("kws{}.web.telegram.org", websocket_dc);
+    let secondary = format!("kws{}-1.web.telegram.org", websocket_dc);
+    let websocket_hosts = if media {
+        [secondary, primary]
+    } else {
+        [primary, secondary]
+    };
+    let ips = telegram_ips(dc);
+    let mut routes = Vec::new();
+
+    for websocket_host in &websocket_hosts {
+        for (index, ip) in ips.iter().enumerate() {
+            routes.push(Route::https(
+                (*ip).to_owned(),
+                websocket_host.clone(),
+                "/apiws".to_owned(),
+                if index == 0 {
+                    RouteKind::TelegramIp
+                } else {
+                    RouteKind::AlternateTelegramIp
+                },
+            ));
+        }
+        routes.push(Route::https(
+            websocket_host.clone(),
+            websocket_host.clone(),
+            "/apiws".to_owned(),
+            RouteKind::SystemDns,
+        ));
+    }
+    routes
+}
+
+async fn connect_route(route: &Route) -> Result<TelegramWebSocket, String> {
+    let tcp = tokio::time::timeout(
+        CONNECT_TIMEOUT,
+        TcpStream::connect((route.connect_host.as_str(), route.port)),
+    )
+    .await
+    .map_err(|_| "TCP connect timeout".to_owned())?
+    .map_err(|error| format!("TCP connect: {}", error))?;
+    tcp.set_nodelay(true)
+        .map_err(|error| format!("TCP_NODELAY: {}", error))?;
+
+    let scheme = if route.secure { "wss" } else { "ws" };
+    let url = format!("{}://{}{}", scheme, route.websocket_host, route.path);
+    let mut request = url
+        .as_str()
+        .into_client_request()
+        .map_err(|error| format!("WebSocket request: {}", error))?;
+    request.headers_mut().insert(
+        "Sec-WebSocket-Protocol",
+        "binary"
+            .parse()
+            .map_err(|error| format!("WebSocket protocol header: {}", error))?,
+    );
+
+    if !route.secure {
+        // Only reachable from tests, which run a local WebSocket server without
+        // a certificate. Production routes are always built by `Route::https`.
+        return tokio::time::timeout(
+            CONNECT_TIMEOUT,
+            tokio_tungstenite::client_async(request, MaybeTlsStream::Plain(tcp)),
+        )
+        .await
+        .map_err(|_| "WebSocket timeout".to_owned())?
+        .map(|(websocket, _)| websocket)
+        .map_err(|error| format!("WebSocket handshake: {}", error));
+    }
+
+    // The URI host remains the real Telegram hostname even when the TCP socket
+    // is opened to a pinned IP. Native TLS therefore validates Telegram's
+    // certificate and sends the correct SNI.
+    let tls = native_tls::TlsConnector::new().map_err(|error| format!("TLS setup: {}", error))?;
+    let connector = tokio_tungstenite::Connector::NativeTls(tls);
+    tokio::time::timeout(
+        CONNECT_TIMEOUT,
+        tokio_tungstenite::client_async_tls_with_config(request, tcp, None, Some(connector)),
+    )
+    .await
+    .map_err(|_| "TLS/WebSocket timeout".to_owned())?
+    .map(|(websocket, _)| websocket)
+    .map_err(|error| format!("TLS/WebSocket handshake: {}", error))
+}
+
+fn valid_domain(domain: &str) -> bool {
+    if domain.is_empty() || domain.len() > 253 || !domain.contains('.') {
+        return false;
+    }
+    domain.split('.').all(|label| {
+        !label.is_empty()
+            && label.len() <= 63
+            && !label.starts_with('-')
+            && !label.ends_with('-')
+            && label
+                .chars()
+                .all(|character| character.is_ascii_alphanumeric() || character == '-')
+    })
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn media_prefers_dash_one_websocket_host() {
+        let routes = routes_for_dc(2, true);
+        assert_eq!(routes[0].websocket_host, "kws2-1.web.telegram.org");
+        assert_eq!(routes[0].connect_host, "149.154.167.51");
+    }
+
+    #[test]
+    fn dc203_uses_dc2_websocket_and_its_own_ip() {
+        let routes = routes_for_dc(203, false);
+        assert_eq!(routes[0].websocket_host, "kws2.web.telegram.org");
+        assert_eq!(routes[0].connect_host, "91.105.192.100");
+    }
+
+    #[test]
+    fn successful_route_becomes_preferred() {
+        let engine = TransportEngine::new();
+        let key = DcKey {
+            dc: 2,
+            media: false,
+        };
+        let preferred = routes_for_dc(2, false)[2].clone();
+        engine.record_success(key, &preferred);
+        assert_eq!(engine.ordered_candidates(key)[0], preferred);
+    }
+
+    #[test]
+    fn failed_route_enters_cooldown() {
+        let engine = TransportEngine::new();
+        let key = DcKey {
+            dc: 2,
+            media: false,
+        };
+        let failed = routes_for_dc(2, false)[0].clone();
+        engine.record_failure(&failed);
+        assert!(!engine.ordered_candidates(key).contains(&failed));
+    }
+
+    #[test]
+    fn worker_is_explicit_and_validated() {
+        let engine = TransportEngine::new();
+        engine.set_worker_domains(&[
+            "Example.User.Workers.dev".to_owned(),
+            "https://invalid.example/path".to_owned(),
+        ]);
+        let routes = engine.routes_for_key(DcKey { dc: 4, media: true });
+        let worker = routes
+            .iter()
+            .find(|route| route.kind == RouteKind::CloudflareWorker)
+            .unwrap();
+        assert_eq!(worker.websocket_host, "example.user.workers.dev");
+        assert_eq!(worker.path, "/apiws?dst=149.154.167.91&dc=4");
+        assert_eq!(
+            routes
+                .iter()
+                .filter(|route| route.kind == RouteKind::CloudflareWorker)
+                .count(),
+            1
+        );
+    }
+
+    #[test]
+    fn every_production_route_is_tls_on_443() {
+        let engine = TransportEngine::new();
+        engine.set_worker_domains(&["fallback.workers.dev".to_owned()]);
+        for dc in [1, 2, 3, 4, 5, 203] {
+            for media in [false, true] {
+                let routes = engine.routes_for_key(DcKey { dc, media });
+                assert!(!routes.is_empty(), "DC{dc} must have at least one route");
+                for route in routes {
+                    assert_eq!(route.port, 443, "{route:?}");
+                    assert!(route.secure, "{route:?}");
+                }
+            }
+        }
+    }
+
+    #[test]
+    fn every_data_center_offers_a_pinned_ip_and_a_dns_route() {
+        for dc in [1, 2, 3, 4, 5, 203] {
+            let routes = routes_for_dc(dc, false);
+            assert!(
+                routes
+                    .iter()
+                    .any(|route| route.kind == RouteKind::TelegramIp),
+                "DC{dc} must keep a pinned-IP route so a poisoned DNS answer is survivable"
+            );
+            assert!(
+                routes
+                    .iter()
+                    .any(|route| route.kind == RouteKind::SystemDns),
+                "DC{dc} must keep a DNS route so a stale pinned IP is survivable"
+            );
+        }
+    }
+
+    #[test]
+    fn backoff_grows_with_each_failure_and_stops_at_the_ceiling() {
+        let engine = TransportEngine::new();
+        let route = routes_for_dc(2, false)[0].clone();
+
+        // 30s doubling per failure, flattening at the 30-minute ceiling.
+        let expected_seconds = [30, 60, 120, 240, 480, 960, 1800, 1800, 1800, 1800];
+        for (index, expected) in expected_seconds.iter().enumerate() {
+            let attempt = u32::try_from(index).unwrap() + 1;
+            let before = Instant::now();
+            engine.record_failure(&route);
+
+            let health = engine.health.lock().unwrap();
+            let entry = health.routes.get(&route).unwrap();
+            assert_eq!(entry.failures, attempt);
+            assert_eq!(
+                entry.retry_at.saturating_duration_since(before).as_secs(),
+                *expected,
+                "attempt {attempt} must wait {expected}s"
+            );
+        }
+        assert_eq!(
+            *expected_seconds.last().unwrap(),
+            FAILURE_BACKOFF_MAX.as_secs(),
+            "the schedule must flatten at the declared ceiling"
+        );
+    }
+
+    #[test]
+    fn success_clears_the_penalty_accumulated_by_failures() {
+        let engine = TransportEngine::new();
+        let key = DcKey {
+            dc: 2,
+            media: false,
+        };
+        let route = routes_for_dc(2, false)[0].clone();
+
+        engine.record_failure(&route);
+        engine.record_failure(&route);
+        assert!(!engine.ordered_candidates(key).contains(&route));
+
+        engine.record_success(key, &route);
+        assert!(!engine.health.lock().unwrap().routes.contains_key(&route));
+        assert_eq!(engine.ordered_candidates(key)[0], route);
+    }
+
+    #[test]
+    fn all_routes_cooling_down_still_yields_the_soonest_retry() {
+        let engine = TransportEngine::new();
+        let key = DcKey {
+            dc: 5,
+            media: false,
+        };
+        let routes = routes_for_dc(5, false);
+
+        // Fail the first route once and the rest twice, so the first one is the
+        // one that becomes available again soonest.
+        engine.record_failure(&routes[0]);
+        for route in &routes[1..] {
+            engine.record_failure(route);
+            engine.record_failure(route);
+        }
+
+        let candidates = engine.ordered_candidates(key);
+        assert_eq!(
+            candidates.len(),
+            1,
+            "a fully cooling table must offer exactly one retry, not give up"
+        );
+        assert_eq!(candidates[0], routes[0]);
+    }
+
+    #[test]
+    fn worker_domains_are_rejected_unless_they_are_plain_hostnames() {
+        let engine = TransportEngine::new();
+        engine.set_worker_domains(&[
+            "https://scheme.workers.dev".to_owned(),
+            "with.a/path".to_owned(),
+            "no-dot".to_owned(),
+            "-leading.workers.dev".to_owned(),
+            "trailing-.workers.dev".to_owned(),
+            "under_score.workers.dev".to_owned(),
+            "spaces here.dev".to_owned(),
+            String::new(),
+            "good.workers.dev".to_owned(),
+        ]);
+
+        let workers: Vec<_> = engine
+            .routes_for_key(DcKey {
+                dc: 2,
+                media: false,
+            })
+            .into_iter()
+            .filter(|route| route.kind == RouteKind::CloudflareWorker)
+            .collect();
+        assert_eq!(workers.len(), 1, "only the valid hostname may survive");
+        assert_eq!(workers[0].websocket_host, "good.workers.dev");
+    }
+
+    #[test]
+    fn worker_domains_are_replaced_not_appended() {
+        let engine = TransportEngine::new();
+        let key = DcKey {
+            dc: 2,
+            media: false,
+        };
+        engine.set_worker_domains(&["first.workers.dev".to_owned()]);
+        engine.set_worker_domains(&["second.workers.dev".to_owned()]);
+
+        let workers: Vec<_> = engine
+            .routes_for_key(key)
+            .into_iter()
+            .filter(|route| route.kind == RouteKind::CloudflareWorker)
+            .collect();
+        assert_eq!(workers.len(), 1);
+        assert_eq!(workers[0].websocket_host, "second.workers.dev");
+    }
+
+    #[test]
+    fn worker_is_the_last_resort() {
+        let engine = TransportEngine::new();
+        engine.set_worker_domains(&["fallback.workers.dev".to_owned()]);
+        let key = DcKey {
+            dc: 2,
+            media: false,
+        };
+        let candidates = engine.ordered_candidates(key);
+        assert_eq!(
+            candidates.last().unwrap().kind,
+            RouteKind::CloudflareWorker,
+            "third-party infrastructure must never be tried before Telegram itself"
+        );
+    }
+
+    #[test]
+    fn documented_worker_contract_matches_the_requested_path() {
+        // docs/CLOUDFLARE_WORKER.md promises exactly this shape.
+        assert_eq!(
+            worker_path(2).unwrap(),
+            "/apiws?dst=149.154.167.51&dc=2",
+            "the documented contract must match what the client requests"
+        );
+        assert_eq!(
+            worker_path(203).unwrap(),
+            "/apiws?dst=91.105.192.100&dc=203"
+        );
+        assert_eq!(worker_path(42), None);
+    }
+
+    #[test]
+    fn worker_allowlist_covers_every_address_a_route_can_ask_for() {
+        let allowed = worker_allowed_destinations();
+        for dc in [1, 2, 3, 4, 5, 203] {
+            for ip in telegram_ips(dc) {
+                assert!(
+                    allowed.contains(ip),
+                    "{ip} is reachable via a route but missing from the Worker allowlist"
+                );
+            }
+        }
+        assert_eq!(
+            allowed.len(),
+            7,
+            "the allowlist in worker/tglock-worker.js must be updated alongside this"
+        );
+    }
+
+    #[test]
+    fn route_codes_and_labels_round_trip() {
+        for kind in [
+            RouteKind::TelegramIp,
+            RouteKind::AlternateTelegramIp,
+            RouteKind::SystemDns,
+            RouteKind::CloudflareWorker,
+        ] {
+            assert_eq!(RouteKind::from_ui_code(kind.ui_code()), Some(kind));
+            assert_eq!(route_label(kind.ui_code()), kind.label());
+        }
+    }
+
+    #[test]
+    fn code_zero_is_never_reported_as_a_working_route() {
+        assert_eq!(RouteKind::from_ui_code(0), None);
+        assert_eq!(RouteKind::from_ui_code(9), None);
+        for kind in [
+            RouteKind::TelegramIp,
+            RouteKind::AlternateTelegramIp,
+            RouteKind::SystemDns,
+            RouteKind::CloudflareWorker,
+        ] {
+            assert_ne!(route_label(0), kind.label());
+        }
+    }
+
+    #[tokio::test]
+    #[ignore = "requires live Telegram network access"]
+    async fn connects_to_all_production_data_centers() {
+        let engine = TransportEngine::new();
+        for dc in [1, 2, 3, 4, 5, 203] {
+            let (mut websocket, connected) = engine.connect(dc, false).await.unwrap();
+            assert!(!connected.route.websocket_host.is_empty());
+            websocket.close(None).await.unwrap();
+        }
+    }
+}

tauri.conf.json

@@ -0,0 +1,51 @@
+{
+  "$schema": "https://schema.tauri.app/config/2",
+  "productName": "TGLock",
+  "version": "2.0.0-beta.6",
+  "identifier": "com.bysonic.tglock",
+  "mainBinaryName": "tglock",
+  "build": {
+    "beforeDevCommand": "npm run dev",
+    "devUrl": "http://localhost:1420",
+    "beforeBuildCommand": "npm run build",
+    "frontendDist": "dist-ui"
+  },
+  "app": {
+    "windows": [
+      {
+        "label": "main",
+        "title": "TGLock",
+        "width": 460,
+        "height": 620,
+        "minWidth": 460,
+        "minHeight": 620,
+        "resizable": false,
+        "fullscreen": false,
+        "center": true,
+        "backgroundColor": "#070A10",
+        "titleBarStyle": "Overlay",
+        "hiddenTitle": true
+      }
+    ],
+    "security": {
+      "csp": "default-src 'self'; style-src 'self' 'unsafe-inline'; img-src 'self' data:; connect-src ipc: http://ipc.localhost"
+    }
+  },
+  "bundle": {
+    "active": true,
+    "targets": ["app", "dmg"],
+    "icon": [
+      "icons/32x32.png",
+      "icons/128x128.png",
+      "icons/128x128@2x.png",
+      "icons/icon.icns",
+      "icons/icon.ico"
+    ],
+    "category": "Utility",
+    "shortDescription": "Telegram connectivity through a local MTProto proxy",
+    "longDescription": "TGLock restores Telegram connectivity through an adaptive WebSocket tunnel.",
+    "macOS": {
+      "minimumSystemVersion": "11.0"
+    }
+  }
+}

tglock.example.toml

@@ -0,0 +1,42 @@
+# Настройки tglock-cli.
+#
+# Положите этот файл рядом с бинарём под именем tglock.toml — он подхватится
+# сам. Либо укажите путь явно: tglock-cli --config /etc/tglock.toml
+#
+# Все поля необязательны. Флаги командной строки перекрывают то, что здесь.
+
+# Адрес и порт локального прокси.
+# По умолчанию 127.0.0.1:1080 — доступ только с этого компьютера.
+# bind = "127.0.0.1"
+# port = 1080
+
+# Слушать 0.0.0.0, чтобы подключались другие устройства в сети.
+# Нельзя задавать одновременно с bind.
+# lan = true
+
+# Секрет прокси — вторая половина ссылки tg://proxy.
+#
+# Для сервиса его нужно закрепить, иначе после перезапуска секрет будет новым и
+# все настроенные клиенты перестанут подключаться. Достаточно один раз
+# запустить tglock-cli, скопировать секрет из напечатанной ссылки и вписать
+# сюда. Принимается и с префиксом dd, и без него.
+#
+# Файл с секретом внутри держите с правами 600: это доступ к вашему прокси.
+# secret = "dd00112233445566778899aabbccddeeff"
+
+# Либо хранить секрет в отдельном файле — он создастся при первом запуске.
+# Игнорируется, если задан secret выше.
+# secret_file = "secret"
+
+# Свои Cloudflare Worker'ы как резервный маршрут — на случай, когда у
+# провайдера легли все обычные маршруты. Установка описана в
+# docs/CLOUDFLARE_WORKER.md
+# worker = ["my-name.workers.dev"]
+
+# Пропускать и не-Telegram адреса.
+# На loopback это включено само. На сетевом адресе означает открытый
+# SOCKS5-прокси для всего интернета — включайте осознанно.
+# allow_direct = false
+
+# Печатать только ошибки.
+# quiet = false

tsconfig.json

@@ -0,0 +1,16 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "useDefineForClassFields": true,
+    "module": "ESNext",
+    "lib": ["ES2022", "DOM", "DOM.Iterable"],
+    "skipLibCheck": true,
+    "moduleResolution": "Bundler",
+    "allowImportingTsExtensions": false,
+    "isolatedModules": true,
+    "moduleDetection": "force",
+    "noEmit": true,
+    "strict": true
+  },
+  "include": ["ui"]
+}

ui/main.ts

@@ -0,0 +1,383 @@
+import { invoke } from "@tauri-apps/api/core";
+import "./styles.css";
+
+type View = "home" | "settings" | "diagnostics";
+
+type Status = {
+  running: boolean;
+  activeConnections: number;
+  tunnels: number;
+  dataCenter: number | null;
+  route: string;
+  failures: number;
+  uptimeSeconds: number;
+  port: number;
+  logs: LogLine[];
+};
+
+type LogLine = {
+  timestamp: string;
+  message: string;
+  error: boolean;
+};
+
+type Settings = {
+  lanMode: boolean;
+  port: number;
+  workerDomain: string;
+};
+
+const root = document.querySelector<HTMLDivElement>("#app")!;
+
+let view: View = "home";
+let status: Status = {
+  running: false,
+  activeConnections: 0,
+  tunnels: 0,
+  dataCenter: null,
+  route: "Маршрут ещё не выбран",
+  failures: 0,
+  uptimeSeconds: 0,
+  port: 1080,
+  logs: [],
+};
+let settings: Settings = { lanMode: false, port: 1080, workerDomain: "" };
+let busy = false;
+let toastTimer: number | undefined;
+
+const icons = {
+  arrowLeft: `<svg viewBox="0 0 24 24" aria-hidden="true"><path d="m15 18-6-6 6-6"/></svg>`,
+  settings: `<svg viewBox="0 0 24 24" aria-hidden="true"><path d="M12 15.5a3.5 3.5 0 1 0 0-7 3.5 3.5 0 0 0 0 7Z"/><path d="M19.4 15a1.7 1.7 0 0 0 .34 1.88l.06.06-2.86 2.86-.06-.06A1.7 1.7 0 0 0 15 19.4a1.7 1.7 0 0 0-1 .6 1.7 1.7 0 0 0-.4 1.1V21H9.6v-.1A1.7 1.7 0 0 0 8.5 19.4a1.7 1.7 0 0 0-1.88.34l-.06.06L3.7 16.94l.06-.06A1.7 1.7 0 0 0 4.1 15a1.7 1.7 0 0 0-.6-1 1.7 1.7 0 0 0-1.1-.4H2.3V9.6h.1A1.7 1.7 0 0 0 4.1 8.5a1.7 1.7 0 0 0-.34-1.88l-.06-.06L6.56 3.7l.06.06A1.7 1.7 0 0 0 8.5 4.1a1.7 1.7 0 0 0 1-.6 1.7 1.7 0 0 0 .4-1.1V2.3h4v.1A1.7 1.7 0 0 0 15 4.1a1.7 1.7 0 0 0 1.88-.34l.06-.06 2.86 2.86-.06.06A1.7 1.7 0 0 0 19.4 8.5a1.7 1.7 0 0 0 .6 1 1.7 1.7 0 0 0 1.1.4h.1v4h-.1a1.7 1.7 0 0 0-1.7 1.1Z"/></svg>`,
+  activity: `<svg viewBox="0 0 24 24" aria-hidden="true"><path d="M3 12h4l2.4-7 5.1 14 2.4-7H21"/></svg>`,
+  plane: `<svg viewBox="0 0 64 64" aria-hidden="true"><path fill="currentColor" d="M52.4 11.7 8.2 28.8c-3 1.2-3 2.8-.6 3.5l11.3 3.5 4.4 13.4c.5 1.5.3 2.1 1.8 2.1 1.2 0 1.7-.5 2.4-1.2l5.5-5.3 11.5 8.5c2.1 1.2 3.7.6 4.2-2l7.6-35.8c.8-3.1-1.2-4.5-3.9-3.8ZM22.7 35l22.1-13.9c1.1-.7 2.1-.3 1.3.4L27.9 38l-.7 7.4L22.7 35Z"/></svg>`,
+};
+
+function escapeHtml(value: string): string {
+  return value
+    .replaceAll("&", "&amp;")
+    .replaceAll("<", "&lt;")
+    .replaceAll(">", "&gt;")
+    .replaceAll('"', "&quot;");
+}
+
+function formatUptime(seconds: number): string {
+  const hours = Math.floor(seconds / 3600);
+  const minutes = Math.floor((seconds % 3600) / 60);
+  const rest = seconds % 60;
+  return [hours, minutes, rest].map((value) => value.toString().padStart(2, "0")).join(":");
+}
+
+function connectionState(): { title: string; subtitle: string; className: string } {
+  if (!status.running) {
+    return {
+      title: "Защита выключена",
+      subtitle: "Нажмите кнопку, чтобы подключить Telegram",
+      className: "offline",
+    };
+  }
+  if (status.failures > 0 && status.tunnels === 0) {
+    return {
+      title: "Ищем новый маршрут",
+      subtitle: "Переключаемся на резервное подключение",
+      className: "warning",
+    };
+  }
+  if (status.tunnels > 0) {
+    return {
+      title: "Telegram на связи",
+      subtitle: "Соединение защищено и работает",
+      className: "online",
+    };
+  }
+  return {
+    title: "Защита включена",
+    subtitle: "Откройте Telegram — маршрут готов",
+    className: "online",
+  };
+}
+
+function shell(content: string, pageClass = ""): string {
+  return `
+    <main class="app-shell ${pageClass}">
+      <div class="drag-region" data-tauri-drag-region></div>
+      ${content}
+      <div id="toast" class="toast" role="status"></div>
+    </main>
+  `;
+}
+
+function renderHome(): void {
+  const connection = connectionState();
+  root.innerHTML = shell(`
+    <section class="home">
+      <header class="brand">
+        <div class="wordmark"><span>TG</span>Lock</div>
+        <p>Свободный Telegram. В один клик.</p>
+      </header>
+
+      <div class="hero ${connection.className}">
+        <div class="orb-field">
+          <div class="orbit orbit-one"></div>
+          <div class="orbit orbit-two"></div>
+          <div class="orb">
+            <div class="orb-shine"></div>
+            ${icons.plane}
+          </div>
+        </div>
+        <div class="connection-copy">
+          <div class="status-line">
+            <span class="status-dot"></span>
+            <h1>${connection.title}</h1>
+          </div>
+          <p>${connection.subtitle}</p>
+        </div>
+      </div>
+
+      <button id="power" class="power-button ${status.running ? "stop" : ""}" ${busy ? "disabled" : ""}>
+        <span>${busy ? "Подождите…" : status.running ? "Выключить" : "Включить защиту"}</span>
+        <span class="button-arrow">→</span>
+      </button>
+
+      <div class="route-pill">
+        <span class="route-pulse"></span>
+        <span>${escapeHtml(status.route)}</span>
+        <span class="route-separator">·</span>
+        <span>порт ${status.port}</span>
+      </div>
+
+      <nav class="bottom-nav" aria-label="Разделы">
+        <button id="settings-nav" class="nav-button">
+          <span class="nav-icon">${icons.settings}</span>
+          <span>Настройки</span>
+        </button>
+        <div class="nav-divider"></div>
+        <button id="diagnostics-nav" class="nav-button">
+          <span class="nav-icon">${icons.activity}</span>
+          <span>Диагностика</span>
+        </button>
+      </nav>
+    </section>
+  `, "home-page");
+
+  document.querySelector("#power")?.addEventListener("click", toggleProtection);
+  document.querySelector("#settings-nav")?.addEventListener("click", () => navigate("settings"));
+  document.querySelector("#diagnostics-nav")?.addEventListener("click", () => navigate("diagnostics"));
+}
+
+function pageHeader(title: string, subtitle: string): string {
+  return `
+    <header class="page-header">
+      <button class="back-button" id="back" aria-label="Назад">${icons.arrowLeft}</button>
+      <div>
+        <h1>${title}</h1>
+        <p>${subtitle}</p>
+      </div>
+    </header>
+  `;
+}
+
+function renderSettings(): void {
+  root.innerHTML = shell(`
+    <section class="subpage">
+      ${pageHeader("Настройки", "Подключение и локальная сеть")}
+
+      <form id="settings-form" class="settings-form">
+        <div class="setting-card">
+          <label class="field-label" for="worker">Cloudflare Worker</label>
+          <input
+            id="worker"
+            name="worker"
+            type="text"
+            value="${escapeHtml(settings.workerDomain)}"
+            placeholder="example.workers.dev"
+            autocomplete="off"
+            ${status.running ? "disabled" : ""}
+          />
+          <p class="field-hint">Необязательно. Используется как резервный маршрут.</p>
+        </div>
+
+        <div class="setting-list">
+          <label class="setting-row" for="lan-mode">
+            <span>
+              <strong>Доступ из локальной сети</strong>
+              <small>Подключение других устройств</small>
+            </span>
+            <span class="switch">
+              <input id="lan-mode" type="checkbox" ${settings.lanMode ? "checked" : ""} ${status.running ? "disabled" : ""}/>
+              <span class="switch-track"></span>
+            </span>
+          </label>
+          <div class="setting-rule"></div>
+          <label class="setting-row compact" for="port">
+            <span>
+              <strong>Локальный порт</strong>
+              <small>SOCKS5 и MTProto</small>
+            </span>
+            <input id="port" class="port-input" type="number" min="1" max="65535" value="${settings.port}" ${status.running ? "disabled" : ""}/>
+          </label>
+        </div>
+
+        ${status.running ? `<div class="locked-note"><span></span>Выключите защиту, чтобы изменить настройки</div>` : ""}
+
+        <button class="save-button" type="submit" ${status.running || busy ? "disabled" : ""}>
+          ${busy ? "Сохраняю…" : "Сохранить настройки"}
+        </button>
+      </form>
+    </section>
+  `, "subpage-shell");
+
+  document.querySelector("#back")?.addEventListener("click", () => navigate("home"));
+  document.querySelector("#settings-form")?.addEventListener("submit", saveSettings);
+}
+
+function renderDiagnostics(): void {
+  const recentLogs = status.logs.slice(-4).reverse();
+  root.innerHTML = shell(`
+    <section class="subpage">
+      ${pageHeader("Диагностика", "Состояние маршрута в реальном времени")}
+
+      <div class="connection-banner ${status.running ? "active" : ""}">
+        <span class="banner-icon">${icons.activity}</span>
+        <div>
+          <strong>${status.running ? "Сервис работает" : "Сервис остановлен"}</strong>
+          <small>${status.running ? "Локальный прокси принимает подключения" : "Включите защиту на главном экране"}</small>
+        </div>
+      </div>
+
+      <div class="metrics-grid">
+        <article class="metric-card">
+          <span>Соединения</span>
+          <strong>${status.activeConnections}</strong>
+        </article>
+        <article class="metric-card">
+          <span>Туннели</span>
+          <strong>${status.tunnels}</strong>
+        </article>
+        <article class="metric-card">
+          <span>Дата-центр</span>
+          <strong>${status.dataCenter ? `DC${status.dataCenter}` : "—"}</strong>
+        </article>
+        <article class="metric-card">
+          <span>Время работы</span>
+          <strong class="time">${formatUptime(status.uptimeSeconds)}</strong>
+        </article>
+      </div>
+
+      <div class="log-panel">
+        <div class="log-heading">
+          <span>Последние события</span>
+          <span class="live-label"><i></i>LIVE</span>
+        </div>
+        <div class="logs">
+          ${recentLogs.length
+            ? recentLogs
+                .map(
+                  (line) => `
+                    <div class="log-line ${line.error ? "error" : ""}">
+                      <time>${line.timestamp}</time>
+                      <span>${escapeHtml(line.message)}</span>
+                    </div>`,
+                )
+                .join("")
+            : `<div class="empty-log">События появятся после включения защиты</div>`}
+        </div>
+      </div>
+    </section>
+  `, "subpage-shell");
+
+  document.querySelector("#back")?.addEventListener("click", () => navigate("home"));
+}
+
+function render(): void {
+  if (view === "settings") renderSettings();
+  else if (view === "diagnostics") renderDiagnostics();
+  else renderHome();
+}
+
+function navigate(next: View): void {
+  view = next;
+  render();
+}
+
+async function refreshStatus(): Promise<void> {
+  try {
+    status = await invoke<Status>("get_status");
+    if (view !== "settings") render();
+  } catch (error) {
+    showToast(String(error), true);
+  }
+}
+
+async function toggleProtection(): Promise<void> {
+  if (busy) return;
+  busy = true;
+  renderHome();
+  try {
+    status = status.running
+      ? await invoke<Status>("stop_proxy")
+      : await invoke<Status>("start_proxy");
+  } catch (error) {
+    showToast(String(error), true);
+  } finally {
+    busy = false;
+    await refreshStatus();
+  }
+}
+
+async function saveSettings(event: Event): Promise<void> {
+  event.preventDefault();
+  if (busy || status.running) return;
+  const worker = document.querySelector<HTMLInputElement>("#worker");
+  const lanMode = document.querySelector<HTMLInputElement>("#lan-mode");
+  const port = document.querySelector<HTMLInputElement>("#port");
+  if (!worker || !lanMode || !port) return;
+
+  const parsedPort = Number(port.value);
+  if (!Number.isInteger(parsedPort) || parsedPort < 1 || parsedPort > 65535) {
+    showToast("Порт должен быть от 1 до 65535", true);
+    return;
+  }
+
+  busy = true;
+  settings = {
+    workerDomain: worker.value.trim(),
+    lanMode: lanMode.checked,
+    port: parsedPort,
+  };
+  renderSettings();
+  try {
+    settings = await invoke<Settings>("save_settings", { settings });
+    showToast("Настройки сохранены");
+    window.setTimeout(() => navigate("home"), 350);
+  } catch (error) {
+    showToast(String(error), true);
+  } finally {
+    busy = false;
+  }
+}
+
+function showToast(message: string, error = false): void {
+  window.clearTimeout(toastTimer);
+  window.requestAnimationFrame(() => {
+    const toast = document.querySelector<HTMLDivElement>("#toast");
+    if (!toast) return;
+    toast.textContent = message.replace(/^["']|["']$/g, "");
+    toast.className = `toast visible${error ? " error" : ""}`;
+    toastTimer = window.setTimeout(() => toast.classList.remove("visible"), 2800);
+  });
+}
+
+async function bootstrap(): Promise<void> {
+  try {
+    [status, settings] = await Promise.all([
+      invoke<Status>("get_status"),
+      invoke<Settings>("get_settings"),
+    ]);
+  } catch {
+    // The browser preview intentionally uses the initial local state.
+  }
+  render();
+  window.setInterval(refreshStatus, 1000);
+}
+
+void bootstrap();

ui/styles.css

@@ -0,0 +1,849 @@
+:root {
+  color-scheme: dark;
+  font-family:
+    Inter, ui-sans-serif, -apple-system, BlinkMacSystemFont, "SF Pro Display",
+    "Segoe UI", sans-serif;
+  font-synthesis: none;
+  text-rendering: geometricPrecision;
+  --bg: #070a10;
+  --panel: rgba(18, 24, 36, 0.78);
+  --panel-strong: #111827;
+  --line: rgba(148, 163, 184, 0.12);
+  --text: #f4f8ff;
+  --muted: #7e8ca3;
+  --blue: #45a9ff;
+  --blue-strong: #168dff;
+  --green: #55e7a6;
+  --red: #ff6b7d;
+}
+
+* {
+  box-sizing: border-box;
+}
+
+html,
+body,
+#app {
+  width: 100%;
+  height: 100%;
+  margin: 0;
+  overflow: hidden;
+}
+
+body {
+  color: var(--text);
+  background: var(--bg);
+  user-select: none;
+}
+
+button,
+input {
+  font: inherit;
+}
+
+button {
+  color: inherit;
+}
+
+.app-shell {
+  position: relative;
+  width: 100%;
+  height: 100%;
+  overflow: hidden;
+  background:
+    radial-gradient(circle at 50% 31%, rgba(19, 116, 220, 0.16), transparent 34%),
+    radial-gradient(circle at 88% 4%, rgba(71, 119, 255, 0.08), transparent 30%),
+    linear-gradient(165deg, #0b1019 0%, #070a10 58%, #090d15 100%);
+}
+
+.app-shell::before {
+  content: "";
+  position: absolute;
+  inset: 0;
+  opacity: 0.13;
+  pointer-events: none;
+  background-image: url("data:image/svg+xml,%3Csvg viewBox='0 0 140 140' xmlns='http://www.w3.org/2000/svg'%3E%3Cfilter id='n'%3E%3CfeTurbulence type='fractalNoise' baseFrequency='.8' numOctaves='3' stitchTiles='stitch'/%3E%3C/filter%3E%3Crect width='100%25' height='100%25' filter='url(%23n)' opacity='.18'/%3E%3C/svg%3E");
+}
+
+.drag-region {
+  position: absolute;
+  z-index: 10;
+  top: 0;
+  left: 0;
+  right: 0;
+  height: 38px;
+}
+
+.home,
+.subpage {
+  position: relative;
+  z-index: 1;
+  height: 100%;
+}
+
+.home {
+  display: flex;
+  flex-direction: column;
+  align-items: center;
+  padding: 48px 34px 24px;
+}
+
+.brand {
+  text-align: center;
+}
+
+.wordmark {
+  font-size: 27px;
+  font-weight: 760;
+  letter-spacing: -1.1px;
+}
+
+.wordmark span {
+  color: var(--blue);
+}
+
+.brand p {
+  margin: 5px 0 0;
+  color: var(--muted);
+  font-size: 12px;
+  font-weight: 480;
+  letter-spacing: 0.08px;
+}
+
+.hero {
+  display: flex;
+  flex-direction: column;
+  align-items: center;
+  margin-top: 24px;
+}
+
+.orb-field {
+  position: relative;
+  display: grid;
+  width: 184px;
+  height: 184px;
+  place-items: center;
+}
+
+.orb-field::before {
+  content: "";
+  position: absolute;
+  width: 108px;
+  height: 108px;
+  border-radius: 50%;
+  background: rgba(35, 126, 221, 0.26);
+  filter: blur(30px);
+  transform: scale(1.25);
+  transition: background 500ms ease;
+}
+
+.online .orb-field::before {
+  background: rgba(33, 203, 149, 0.28);
+}
+
+.orbit {
+  position: absolute;
+  border: 1px solid rgba(83, 174, 255, 0.15);
+  border-radius: 50%;
+}
+
+.orbit-one {
+  inset: 10px;
+  border-left-color: rgba(79, 172, 255, 0.48);
+  transform: rotate(-30deg);
+}
+
+.orbit-two {
+  inset: 22px;
+  border-right-color: rgba(79, 172, 255, 0.34);
+  transform: rotate(22deg);
+}
+
+.orb {
+  position: relative;
+  display: grid;
+  width: 112px;
+  height: 112px;
+  overflow: hidden;
+  color: white;
+  border: 1px solid rgba(137, 204, 255, 0.66);
+  border-radius: 50%;
+  place-items: center;
+  background:
+    linear-gradient(145deg, rgba(255, 255, 255, 0.16), transparent 40%),
+    linear-gradient(145deg, #269fff, #0d5fbd);
+  box-shadow:
+    inset 0 1px 1px rgba(255, 255, 255, 0.38),
+    inset 0 -14px 28px rgba(1, 21, 56, 0.28),
+    0 0 0 8px rgba(34, 129, 223, 0.06),
+    0 18px 45px rgba(2, 90, 183, 0.34);
+  transition: filter 300ms ease, background 500ms ease;
+}
+
+.offline .orb {
+  filter: saturate(0.44) brightness(0.72);
+}
+
+.online .orb {
+  border-color: rgba(112, 245, 192, 0.72);
+  background:
+    linear-gradient(145deg, rgba(255, 255, 255, 0.16), transparent 40%),
+    linear-gradient(145deg, #29c995, #087e78);
+  box-shadow:
+    inset 0 1px 1px rgba(255, 255, 255, 0.38),
+    inset 0 -14px 28px rgba(1, 46, 54, 0.28),
+    0 0 0 8px rgba(34, 220, 157, 0.06),
+    0 18px 45px rgba(9, 182, 133, 0.3);
+}
+
+.orb svg {
+  z-index: 1;
+  width: 55px;
+  height: 55px;
+  transform: translate(-1px, 1px);
+  filter: drop-shadow(0 5px 10px rgba(0, 32, 75, 0.3));
+}
+
+.orb-shine {
+  position: absolute;
+  top: -34px;
+  left: 6px;
+  width: 96px;
+  height: 72px;
+  border-radius: 50%;
+  background: rgba(255, 255, 255, 0.11);
+  transform: rotate(-20deg);
+  filter: blur(5px);
+}
+
+.connection-copy {
+  margin-top: 11px;
+  text-align: center;
+}
+
+.status-line {
+  display: flex;
+  align-items: center;
+  justify-content: center;
+  gap: 9px;
+}
+
+.status-line h1 {
+  margin: 0;
+  font-size: 19px;
+  font-weight: 680;
+  letter-spacing: -0.3px;
+}
+
+.status-dot {
+  width: 7px;
+  height: 7px;
+  border-radius: 50%;
+  background: #526177;
+  box-shadow: 0 0 0 4px rgba(82, 97, 119, 0.11);
+}
+
+.online .status-dot {
+  background: var(--green);
+  box-shadow: 0 0 12px rgba(85, 231, 166, 0.8);
+}
+
+.warning .status-dot {
+  background: #ffbf5b;
+}
+
+.connection-copy p {
+  margin: 6px 0 0;
+  color: var(--muted);
+  font-size: 11.5px;
+}
+
+.power-button {
+  display: flex;
+  width: 100%;
+  height: 54px;
+  margin-top: 24px;
+  padding: 0 21px 0 25px;
+  cursor: pointer;
+  border: 1px solid rgba(118, 196, 255, 0.5);
+  border-radius: 16px;
+  align-items: center;
+  justify-content: space-between;
+  background:
+    linear-gradient(180deg, rgba(255, 255, 255, 0.14), transparent),
+    linear-gradient(135deg, #3eaaff, #1685ee);
+  box-shadow:
+    inset 0 1px 0 rgba(255, 255, 255, 0.26),
+    0 12px 28px rgba(7, 103, 204, 0.28);
+  font-size: 14px;
+  font-weight: 690;
+  transition: transform 150ms ease, filter 150ms ease, box-shadow 150ms ease;
+}
+
+.power-button:hover {
+  filter: brightness(1.08);
+  box-shadow:
+    inset 0 1px 0 rgba(255, 255, 255, 0.26),
+    0 14px 34px rgba(7, 103, 204, 0.38);
+}
+
+.power-button:active {
+  transform: scale(0.985);
+}
+
+.power-button.stop {
+  color: #c9d6e8;
+  border-color: rgba(148, 163, 184, 0.18);
+  background: rgba(26, 34, 48, 0.8);
+  box-shadow: inset 0 1px 0 rgba(255, 255, 255, 0.04);
+}
+
+.power-button:disabled {
+  cursor: default;
+  opacity: 0.62;
+}
+
+.button-arrow {
+  font-size: 20px;
+  font-weight: 400;
+}
+
+.route-pill {
+  display: flex;
+  height: 30px;
+  margin-top: 12px;
+  padding: 0 12px;
+  color: #78879e;
+  border: 1px solid var(--line);
+  border-radius: 999px;
+  align-items: center;
+  gap: 7px;
+  background: rgba(17, 24, 37, 0.54);
+  font-size: 10px;
+}
+
+.route-pulse {
+  width: 5px;
+  height: 5px;
+  border-radius: 50%;
+  background: var(--blue);
+  box-shadow: 0 0 8px rgba(69, 169, 255, 0.7);
+}
+
+.route-separator {
+  opacity: 0.45;
+}
+
+.bottom-nav {
+  display: flex;
+  width: 100%;
+  margin-top: auto;
+  padding: 11px 8px 3px;
+  border-top: 1px solid var(--line);
+  justify-content: center;
+}
+
+.nav-button {
+  display: flex;
+  min-width: 134px;
+  height: 38px;
+  padding: 0 14px;
+  cursor: pointer;
+  color: #8694aa;
+  border: 0;
+  border-radius: 11px;
+  align-items: center;
+  justify-content: center;
+  gap: 8px;
+  background: transparent;
+  font-size: 11px;
+  transition: color 150ms ease, background 150ms ease;
+}
+
+.nav-button:hover {
+  color: #cbd8ea;
+  background: rgba(255, 255, 255, 0.035);
+}
+
+.nav-icon,
+.banner-icon {
+  display: grid;
+  place-items: center;
+}
+
+.nav-icon svg {
+  width: 17px;
+  height: 17px;
+  fill: none;
+  stroke: currentColor;
+  stroke-width: 1.6;
+  stroke-linecap: round;
+  stroke-linejoin: round;
+}
+
+.nav-divider {
+  width: 1px;
+  height: 20px;
+  margin: 9px 5px;
+  background: var(--line);
+}
+
+.subpage {
+  padding: 54px 30px 26px;
+}
+
+.subpage-shell {
+  background:
+    radial-gradient(circle at 100% 0, rgba(32, 123, 220, 0.13), transparent 35%),
+    linear-gradient(165deg, #0b1019, #070a10);
+}
+
+.page-header {
+  display: flex;
+  align-items: center;
+  gap: 14px;
+}
+
+.back-button {
+  display: grid;
+  width: 38px;
+  height: 38px;
+  padding: 0;
+  cursor: pointer;
+  color: #bdc9da;
+  border: 1px solid var(--line);
+  border-radius: 12px;
+  place-items: center;
+  background: rgba(18, 26, 40, 0.72);
+  transition: background 150ms ease, border-color 150ms ease;
+}
+
+.back-button:hover {
+  border-color: rgba(92, 174, 255, 0.3);
+  background: rgba(28, 42, 61, 0.82);
+}
+
+.back-button svg {
+  width: 18px;
+  fill: none;
+  stroke: currentColor;
+  stroke-width: 1.8;
+  stroke-linecap: round;
+  stroke-linejoin: round;
+}
+
+.page-header h1 {
+  margin: 0;
+  font-size: 22px;
+  font-weight: 720;
+  letter-spacing: -0.5px;
+}
+
+.page-header p {
+  margin: 4px 0 0;
+  color: var(--muted);
+  font-size: 11px;
+}
+
+.settings-form {
+  margin-top: 27px;
+}
+
+.setting-card,
+.setting-list,
+.connection-banner,
+.metric-card,
+.log-panel {
+  border: 1px solid var(--line);
+  background:
+    linear-gradient(145deg, rgba(255, 255, 255, 0.025), transparent),
+    rgba(15, 22, 34, 0.76);
+  box-shadow: inset 0 1px 0 rgba(255, 255, 255, 0.025);
+}
+
+.setting-card {
+  padding: 18px;
+  border-radius: 16px;
+}
+
+.field-label {
+  display: block;
+  margin-bottom: 10px;
+  color: #dfe8f5;
+  font-size: 12px;
+  font-weight: 630;
+}
+
+.setting-card input,
+.port-input {
+  color: var(--text);
+  outline: none;
+  border: 1px solid rgba(125, 154, 190, 0.18);
+  background: rgba(6, 10, 17, 0.72);
+  transition: border-color 150ms ease, box-shadow 150ms ease;
+}
+
+.setting-card input {
+  width: 100%;
+  height: 42px;
+  padding: 0 13px;
+  border-radius: 11px;
+  font-size: 12px;
+}
+
+.setting-card input:focus,
+.port-input:focus {
+  border-color: rgba(69, 169, 255, 0.65);
+  box-shadow: 0 0 0 3px rgba(69, 169, 255, 0.1);
+}
+
+input::placeholder {
+  color: #4f5b6d;
+}
+
+input:disabled {
+  cursor: not-allowed;
+  opacity: 0.55;
+}
+
+.field-hint {
+  margin: 8px 0 0;
+  color: #66758b;
+  font-size: 9.5px;
+}
+
+.setting-list {
+  margin-top: 13px;
+  padding: 4px 18px;
+  border-radius: 16px;
+}
+
+.setting-row {
+  display: flex;
+  min-height: 68px;
+  align-items: center;
+  justify-content: space-between;
+}
+
+.setting-row strong {
+  display: block;
+  font-size: 12px;
+  font-weight: 620;
+}
+
+.setting-row small {
+  display: block;
+  margin-top: 4px;
+  color: var(--muted);
+  font-size: 9.5px;
+}
+
+.setting-rule {
+  height: 1px;
+  background: var(--line);
+}
+
+.switch {
+  position: relative;
+  width: 42px;
+  height: 24px;
+}
+
+.switch input {
+  position: absolute;
+  opacity: 0;
+}
+
+.switch-track {
+  position: absolute;
+  inset: 0;
+  cursor: pointer;
+  border: 1px solid rgba(148, 163, 184, 0.2);
+  border-radius: 999px;
+  background: #202a39;
+  transition: background 180ms ease;
+}
+
+.switch-track::after {
+  content: "";
+  position: absolute;
+  top: 3px;
+  left: 3px;
+  width: 16px;
+  height: 16px;
+  border-radius: 50%;
+  background: #8e9bad;
+  box-shadow: 0 2px 5px rgba(0, 0, 0, 0.3);
+  transition: transform 180ms ease, background 180ms ease;
+}
+
+.switch input:checked + .switch-track {
+  border-color: rgba(69, 169, 255, 0.5);
+  background: var(--blue-strong);
+}
+
+.switch input:checked + .switch-track::after {
+  background: white;
+  transform: translateX(18px);
+}
+
+.port-input {
+  width: 78px;
+  height: 34px;
+  text-align: center;
+  border-radius: 10px;
+  font-size: 12px;
+  appearance: textfield;
+}
+
+.locked-note {
+  display: flex;
+  margin: 13px 2px 0;
+  color: #8d9aab;
+  align-items: center;
+  gap: 8px;
+  font-size: 10px;
+}
+
+.locked-note span {
+  width: 6px;
+  height: 6px;
+  border-radius: 50%;
+  background: #ffb84f;
+}
+
+.save-button {
+  width: 100%;
+  height: 48px;
+  margin-top: 18px;
+  cursor: pointer;
+  color: white;
+  border: 1px solid rgba(100, 186, 255, 0.45);
+  border-radius: 14px;
+  background: linear-gradient(135deg, #36a8ff, #147fe8);
+  box-shadow: 0 10px 24px rgba(6, 94, 185, 0.22);
+  font-size: 12px;
+  font-weight: 680;
+}
+
+.save-button:disabled {
+  cursor: not-allowed;
+  opacity: 0.45;
+  box-shadow: none;
+}
+
+.connection-banner {
+  display: flex;
+  margin-top: 27px;
+  padding: 16px;
+  border-radius: 16px;
+  align-items: center;
+  gap: 13px;
+}
+
+.connection-banner.active {
+  border-color: rgba(68, 219, 159, 0.18);
+  background:
+    linear-gradient(145deg, rgba(44, 207, 151, 0.055), transparent),
+    rgba(15, 22, 34, 0.76);
+}
+
+.banner-icon {
+  width: 38px;
+  height: 38px;
+  color: #7c8da5;
+  border-radius: 12px;
+  background: rgba(112, 129, 153, 0.1);
+}
+
+.active .banner-icon {
+  color: var(--green);
+  background: rgba(65, 221, 159, 0.1);
+}
+
+.banner-icon svg {
+  width: 19px;
+  fill: none;
+  stroke: currentColor;
+  stroke-width: 1.7;
+  stroke-linecap: round;
+  stroke-linejoin: round;
+}
+
+.connection-banner strong,
+.connection-banner small {
+  display: block;
+}
+
+.connection-banner strong {
+  font-size: 12px;
+}
+
+.connection-banner small {
+  margin-top: 4px;
+  color: var(--muted);
+  font-size: 9.5px;
+}
+
+.metrics-grid {
+  display: grid;
+  margin-top: 13px;
+  grid-template-columns: repeat(2, 1fr);
+  gap: 10px;
+}
+
+.metric-card {
+  height: 84px;
+  padding: 16px;
+  border-radius: 15px;
+}
+
+.metric-card span {
+  display: block;
+  color: var(--muted);
+  font-size: 9.5px;
+}
+
+.metric-card strong {
+  display: block;
+  margin-top: 9px;
+  font-size: 21px;
+  letter-spacing: -0.5px;
+}
+
+.metric-card strong.time {
+  font-family: "SF Mono", ui-monospace, monospace;
+  font-size: 17px;
+  letter-spacing: -0.7px;
+}
+
+.log-panel {
+  margin-top: 13px;
+  padding: 16px;
+  border-radius: 16px;
+}
+
+.log-heading {
+  display: flex;
+  color: #dbe5f3;
+  align-items: center;
+  justify-content: space-between;
+  font-size: 10px;
+  font-weight: 640;
+}
+
+.live-label {
+  display: flex;
+  color: #65748a;
+  align-items: center;
+  gap: 5px;
+  font-size: 8px;
+  letter-spacing: 0.7px;
+}
+
+.live-label i {
+  width: 5px;
+  height: 5px;
+  border-radius: 50%;
+  background: var(--green);
+  box-shadow: 0 0 7px rgba(85, 231, 166, 0.75);
+}
+
+.logs {
+  min-height: 96px;
+  margin-top: 13px;
+}
+
+.log-line {
+  display: grid;
+  padding: 6px 0;
+  color: #8c9ab0;
+  grid-template-columns: 58px 1fr;
+  gap: 6px;
+  font-family: "SF Mono", ui-monospace, monospace;
+  font-size: 8.7px;
+  line-height: 1.35;
+}
+
+.log-line.error {
+  color: var(--red);
+}
+
+.log-line time {
+  color: #556276;
+}
+
+.empty-log {
+  display: grid;
+  height: 92px;
+  color: #59677b;
+  place-items: center;
+  font-size: 9px;
+}
+
+.toast {
+  position: absolute;
+  z-index: 20;
+  left: 50%;
+  bottom: 22px;
+  max-width: calc(100% - 48px);
+  padding: 10px 14px;
+  pointer-events: none;
+  color: #dff9ed;
+  border: 1px solid rgba(73, 222, 161, 0.25);
+  border-radius: 10px;
+  opacity: 0;
+  background: rgba(16, 44, 38, 0.94);
+  box-shadow: 0 10px 30px rgba(0, 0, 0, 0.3);
+  font-size: 10px;
+  text-align: center;
+  transform: translate(-50%, 8px);
+  transition: opacity 160ms ease, transform 160ms ease;
+}
+
+.toast.error {
+  color: #ffe0e4;
+  border-color: rgba(255, 107, 125, 0.25);
+  background: rgba(60, 23, 32, 0.96);
+}
+
+.toast.visible {
+  opacity: 1;
+  transform: translate(-50%, 0);
+}
+
+@media (prefers-reduced-motion: no-preference) {
+  .online .orbit-one {
+    animation: orbit-spin 12s linear infinite;
+  }
+
+  .online .orbit-two {
+    animation: orbit-spin-reverse 16s linear infinite;
+  }
+
+  .online .orb {
+    animation: orb-breathe 3.6s ease-in-out infinite;
+  }
+}
+
+@keyframes orbit-spin {
+  to {
+    transform: rotate(330deg);
+  }
+}
+
+@keyframes orbit-spin-reverse {
+  to {
+    transform: rotate(-338deg);
+  }
+}
+
+@keyframes orb-breathe {
+  50% {
+    box-shadow:
+      inset 0 1px 1px rgba(255, 255, 255, 0.38),
+      inset 0 -14px 28px rgba(1, 46, 54, 0.28),
+      0 0 0 11px rgba(34, 220, 157, 0.04),
+      0 19px 52px rgba(9, 182, 133, 0.4);
+  }
+}

vite.config.ts

@@ -0,0 +1,14 @@
+import { defineConfig } from "vite";
+
+export default defineConfig({
+  clearScreen: false,
+  build: {
+    outDir: "dist-ui",
+  },
+  server: {
+    strictPort: true,
+    watch: {
+      ignored: ["**/target/**"],
+    },
+  },
+});

worker/tglock-worker.js

@@ -0,0 +1,104 @@
+// Резервный маршрут TGLock через Cloudflare Worker.
+//
+// Нужен в одном случае: провайдер заблокировал саму веб-инфраструктуру
+// Telegram, и все обычные маршруты TGLock перестали отвечать. Тогда соединение
+// идёт на твой домен *.workers.dev, а воркер доводит его до Telegram.
+//
+// Инструкция по установке: docs/CLOUDFLARE_WORKER.md
+//
+// Контракт, который ожидает клиент (src/transport.rs):
+//   wss://<домен>/apiws?dst=<telegram-ip>&dc=<номер-dc>
+//   заголовок Sec-WebSocket-Protocol: binary — его обязательно нужно
+//   подтвердить в ответе, иначе клиент разорвёт рукопожатие;
+//   бинарные frames в обе стороны, без обёрток.
+
+import { connect } from "cloudflare:sockets";
+
+// Только те адреса, которые запрашивает сам TGLock. Без этого списка любой,
+// кто узнает адрес воркера, получит через твой аккаунт произвольный
+// TCP-прокси.
+const ALLOWED_DESTINATIONS = new Set([
+  "91.105.192.100",
+  "149.154.167.51",
+  "149.154.167.91",
+  "149.154.167.220",
+  "149.154.171.5",
+  "149.154.175.50",
+  "149.154.175.100",
+]);
+
+const TELEGRAM_PORT = 443;
+
+export default {
+  async fetch(request, env) {
+    const url = new URL(request.url);
+
+    if (url.pathname !== "/apiws") {
+      return new Response("not found", { status: 404 });
+    }
+    if (request.headers.get("Upgrade")?.toLowerCase() !== "websocket") {
+      return new Response("expected a websocket upgrade", { status: 426 });
+    }
+    // Необязательный общий секрет: задай переменную TGLOCK_TOKEN в настройках
+    // воркера, и посторонние подключиться не смогут.
+    if (env.TGLOCK_TOKEN && url.searchParams.get("token") !== env.TGLOCK_TOKEN) {
+      return new Response("forbidden", { status: 403 });
+    }
+
+    const destination = url.searchParams.get("dst");
+    if (!destination || !ALLOWED_DESTINATIONS.has(destination)) {
+      return new Response("destination not allowed", { status: 403 });
+    }
+
+    const [client, server] = Object.values(new WebSocketPair());
+    server.accept();
+
+    const upstream = connect({ hostname: destination, port: TELEGRAM_PORT });
+    const writer = upstream.writable.getWriter();
+    let closed = false;
+
+    const shutdown = () => {
+      if (closed) return;
+      closed = true;
+      writer.close().catch(() => {});
+      try {
+        server.close();
+      } catch {
+        // соединение уже закрыто
+      }
+    };
+
+    server.addEventListener("message", (event) => {
+      const chunk =
+        event.data instanceof ArrayBuffer
+          ? new Uint8Array(event.data)
+          : event.data;
+      writer.write(chunk).catch(shutdown);
+    });
+    server.addEventListener("close", shutdown);
+    server.addEventListener("error", shutdown);
+
+    // Обратное направление: всё, что приходит от Telegram, уходит клиенту.
+    (async () => {
+      const reader = upstream.readable.getReader();
+      try {
+        for (;;) {
+          const { value, done } = await reader.read();
+          if (done) break;
+          server.send(value);
+        }
+      } catch {
+        // разрыв соединения — обычная ситуация, не ошибка
+      }
+      shutdown();
+    })();
+
+    return new Response(null, {
+      status: 101,
+      webSocket: client,
+      // Обязательно: клиент запрашивает подпротокол binary и без
+      // подтверждения рвёт рукопожатие.
+      headers: { "Sec-WebSocket-Protocol": "binary" },
+    });
+  },
+};