fix(ci): одна проверка бандла на Python вместо трёх копий grep (#34 )

* fix(bundle): спрятать CLI за фичей — beta.2 и beta.3 упаковывали не тот бинарь Мой предыдущий фикс (mainBinaryName в #31) фиксом не был. Он изменил только имя выходного файла: бандлер по-прежнему брал headless CLI и просто переименовывал его в tglock. Проверено по содержимому опубликованных артефактов, а не по имени: версия файл в MacOS/ размер признаки CLI признаки GUI beta.1 tglock 17.8 МБ нет ipc.localhost, wry×3206 beta.2 tglock-cli 4.3 МБ tglock-cli×6 нет beta.3 tglock 4.3 МБ tglock-cli×6 нет То есть beta.3 тоже не запускается, и моя же проверка CFBundleExecutable это пропустила, потому что сверяла имя. Настоящая причина найдена воспроизведением локально. Ломается только при явном --target: без него бандлер выбирает GUI, с ним — CLI. Локальная сборка, на которой я объявил фикс подтверждённым, шла без --target, а обе сборки в CI — с ним. Обобщение было неправомерным. Исправление убирает саму возможность выбора: CLI спрятан за фичей cli, которой нет в default. При сборке приложения второго бинаря просто не существует. Проверено против воспроизведённой поломки: до : tglock.exe 1.7 МБ, признаки CLI, GUI нет после: tglock.exe 9.0 МБ, признаки GUI, CLI нет, tglock-cli.exe не собран Проверки переписаны на содержимое: - release.yml распаковывает .app и .deb и ищет ipc.localhost (есть только в GUI) и allow-direct (есть только в CLI). Поймала бы и beta.2, и beta.3; - новая задача CI bundle собирает бандл с явным --target aarch64-apple-darwin и проверяет его так же. Ловит до публикации, а не после; - заодно исправлен шаблон grep для .deb: dpkg-deb -c выводит путь без ./, из-за чего проверка ложно падала на исправной сборке. Команда сборки CLI теперь требует --features cli; обновлены README, ci.yml и release.yml. * fix(ci): одна проверка бандла на Python вместо трёх копий grep Проверка содержимого бандла, добавленная в #33, работала на Linux и давала ложное «в бандле не GUI» на macOS. Причина в BSD grep: в UTF-8-локали он молча не находит строки в бинарных данных там, где GNU grep находит. Из-за этого задача macOS в релизе beta.4 упала уже после загрузки артефактов, а вместе с ней снова пропустилась задача с CLI-бинарями. Сами артефакты beta.4 при этом корректны — проверено скачиванием: в бандле tglock на 20.3 МБ, universal/fat, признаки GUI на месте, признаков CLI нет. Не хватает только tglock-cli-*. Проверка вынесена в scripts/verify_bundle_binary.py и вызывается из всех трёх мест: задачи CI bundle, проверки macOS и проверки Linux в релизе. Один скрипт вместо трёх копий шелл-кода исключает и платформенные различия grep, и расхождение копий между собой. Скрипт проверен на реальных исторических артефактах: beta.4 (исправный) → код 0 beta.3 (сломанный) → код 1, найдены allow-direct и secret-file beta.2 (сломанный) → код 1, то же --------- Co-authored-by: by-sonic <171230345+by-sonic@users.noreply.github.com>
fix(bundle): спрятать CLI за фичей — beta.2 и beta.3 упаковывали не тот бинарь (#33 )
2026-07-31 07:45:13 +03:00 · 2026-07-30 16:26:32 +03:00 · 2026-07-30 16:08:56 +03:00 · 2026-07-30 15:40:18 +03:00 · 2026-07-30 14:15:47 +03:00 · 2026-07-30 14:06:19 +03:00
22 changed files with 2753 additions and 231 deletions
@@ -29,6 +29,26 @@ jobs:
        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
@@ -38,6 +58,83 @@ jobs:
      - 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)"
  msrv:
    name: Rust 1.88 compatibility
    runs-on: macos-latest
@@ -59,6 +156,9 @@ jobs:
      - 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
@@ -70,6 +70,104 @@ jobs:
            - macOS: скачайте универсальный `.dmg` или `.app.tar.gz`
            - Windows: скачайте `.exe` установщик
            - Linux: скачайте `.AppImage` или `.deb`
            - Сервер или машина без монитора: скачайте `tglock-cli-*` — там нет графического интерфейса
          releaseDraft: false
-          prerelease: true
+          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 }}
    steps:
      - uses: actions/checkout@v6
      # No Node.js and no desktop libraries: the CLI must build without them.
      - name: Install Rust
        uses: dtolnay/rust-toolchain@stable
        with:
          targets: ${{ matrix.rust-targets }}
      - 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
      - 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
      - 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 }}
@@ -52,6 +52,56 @@ dependencies = [
 "libc",
 ]
 [[package]]
 name = "anstream"
 version = "1.0.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "824a212faf96e9acacdbd09febd34438f8f711fb84e09a8916013cd7815ca28d"
 dependencies = [
 "anstyle",
 "anstyle-parse",
 "anstyle-query",
 "anstyle-wincon",
 "colorchoice",
 "is_terminal_polyfill",
 "utf8parse",
 ]
 [[package]]
 name = "anstyle"
 version = "1.0.14"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "940b3a0ca603d1eade50a4846a2afffd5ef57a9feac2c0e2ec2e14f9ead76000"
 [[package]]
 name = "anstyle-parse"
 version = "1.0.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "52ce7f38b242319f7cabaa6813055467063ecdc9d355bbb4ce0c68908cd8130e"
 dependencies = [
 "utf8parse",
 ]
 [[package]]
 name = "anstyle-query"
 version = "1.1.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "40c48f72fd53cd289104fc64099abca73db4166ad86ea0b4341abe65af83dadc"
 dependencies = [
 "windows-sys 0.61.2",
 ]
 [[package]]
 name = "anstyle-wincon"
 version = "3.0.11"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "291e6a250ff86cd4a820112fb8898808a366d8f9f58ce16d1f538353ad55747d"
 dependencies = [
 "anstyle",
 "once_cell_polyfill",
 "windows-sys 0.61.2",
 ]
 [[package]]
 name = "anyhow"
 version = "1.0.104"
@@ -342,6 +392,52 @@ dependencies = [
 "inout",
 ]
 [[package]]
 name = "clap"
 version = "4.6.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "d91e0c145792ef73a6ad36d27c75ac09f1832222a3c209689d90f534685ee5b7"
 dependencies = [
 "clap_builder",
 "clap_derive",
 ]
 [[package]]
 name = "clap_builder"
 version = "4.6.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "f09628afdcc538b57f3c6341e9c8e9970f18e4a481690a64974d7023bd33548b"
 dependencies = [
 "anstream",
 "anstyle",
 "clap_lex",
 "strsim",
 ]
 [[package]]
 name = "clap_derive"
 version = "4.6.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "d012d2b9d65aca7f18f4d9878a045bc17899bba951561ba5ec3c2ba1eed9a061"
 dependencies = [
 "heck 0.5.0",
 "proc-macro2",
 "quote",
 "syn 3.0.3",
 ]
 [[package]]
 name = "clap_lex"
 version = "1.1.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "c8d4a3bb8b1e0c1050499d1815f5ab16d04f0959b233085fb31653fbfc9d98f9"
 [[package]]
 name = "colorchoice"
 version = "1.0.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "1d07550c9036bf2ae0c684c4297d503f838287c83c53686d05370d0e139ae570"
 [[package]]
 name = "combine"
 version = "4.6.7"
@@ -1364,7 +1460,7 @@ dependencies = [
 "js-sys",
 "log",
 "wasm-bindgen",
- "windows-core 0.58.0",
+ "windows-core",
 ]
 [[package]]
@@ -1561,6 +1657,12 @@ dependencies = [
 "once_cell",
 ]
 [[package]]
 name = "is_terminal_polyfill"
 version = "1.70.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "a6cb138bb79a146c1bd460005623e142ef0181e3d0219cb493e02f7d08a35695"
 [[package]]
 name = "itoa"
 version = "1.0.18"
@@ -2122,6 +2224,12 @@ version = "1.21.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "9f7c3e4beb33f85d45ae3e3a1792185706c8e16d043238c593331cc7cd313b50"
 [[package]]
 name = "once_cell_polyfill"
 version = "1.70.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "384b8ab6d37215f3c5301a95a4accb5d64aa607f1fcb26a11b5303878451b4fe"
 [[package]]
 name = "open"
 version = "5.4.0"
@@ -2947,6 +3055,16 @@ version = "2.0.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "f8fadd59c855ef2080decdef8ff161eb6661b86933c9d82e5ba29dc602a55aba"
 [[package]]
 name = "signal-hook-registry"
 version = "1.4.8"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "c4db69cba1110affc0e9f7bcd48bbf87b3f4fc7c61fc9155afd4c469eb3d6c1b"
 dependencies = [
 "errno",
 "libc",
 ]
 [[package]]
 name = "simd-adler32"
 version = "0.3.10"
@@ -3176,7 +3294,7 @@ dependencies = [
 "unicode-segmentation",
 "url",
 "windows",
- "windows-core 0.61.2",
+ "windows-core",
 "windows-version",
 "x11-dl",
 ]
@@ -3435,10 +3553,11 @@ dependencies = [
 [[package]]
 name = "tglock"
-version = "2.0.0-beta.1"
+version = "2.0.0-beta.5"
 dependencies = [
 "aes",
 "cipher",
 "clap",
 "ctr",
 "futures-util",
 "native-tls",
@@ -3558,6 +3677,7 @@ dependencies = [
 "libc",
 "mio",
 "pin-project-lite",
 "signal-hook-registry",
 "socket2",
 "tokio-macros",
 "windows-sys 0.61.2",
@@ -3944,6 +4064,12 @@ version = "1.0.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "b6c140620e7ffbb22c2dee59cafe6084a59b5ffc27a8859a5f0d494b5d52b6be"
 [[package]]
 name = "utf8parse"
 version = "0.2.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "06abde3611657adf66d383f00b093d7faecc7fa57071cce2578660c9f1010821"
 [[package]]
 name = "uuid"
 version = "1.24.0"
@@ -4171,9 +4297,9 @@ dependencies = [
 "webview2-com-macros",
 "webview2-com-sys",
 "windows",
- "windows-core 0.61.2",
+ "windows-core",
- "windows-implement 0.60.2",
+ "windows-implement",
- "windows-interface 0.59.3",
+ "windows-interface",
 ]
 [[package]]
@@ -4195,7 +4321,7 @@ checksum = "381336cfffd772377d291702245447a5251a2ffa5bad679c99e61bc48bacbf9c"
 dependencies = [
 "thiserror 2.0.19",
 "windows",
- "windows-core 0.61.2",
+ "windows-core",
 ]
 [[package]]
@@ -4251,7 +4377,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "9babd3a767a4c1aef6900409f85f5d53ce2544ccdfaa86dad48c91782c6d6893"
 dependencies = [
 "windows-collections",
- "windows-core 0.61.2",
+ "windows-core",
 "windows-future",
 "windows-link 0.1.3",
 "windows-numerics",
@@ -4263,20 +4389,7 @@ version = "0.2.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "3beeceb5e5cfd9eb1d76b381630e82c4241ccd0d27f1a39ed41b2760b255c5e8"
 dependencies = [
- "windows-core 0.61.2",
+ "windows-core",
 ]
 [[package]]
 name = "windows-core"
 version = "0.58.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "6ba6d44ec8c2591c134257ce647b7ea6b20335bf6379a27dac5f1641fcf59f99"
 dependencies = [
 "windows-implement 0.58.0",
 "windows-interface 0.58.0",
 "windows-result 0.2.0",
 "windows-strings 0.1.0",
 "windows-targets 0.52.6",
 ]
 [[package]]
@@ -4285,11 +4398,11 @@ version = "0.61.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "c0fdd3ddb90610c7638aa2b3a3ab2904fb9e5cdbecc643ddb3647212781c4ae3"
 dependencies = [
- "windows-implement 0.60.2",
+ "windows-implement",
- "windows-interface 0.59.3",
+ "windows-interface",
 "windows-link 0.1.3",
- "windows-result 0.3.4",
+ "windows-result",
- "windows-strings 0.4.2",
+ "windows-strings",
 ]
 [[package]]
@@ -4298,22 +4411,11 @@ version = "0.2.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "fc6a41e98427b19fe4b73c550f060b59fa592d7d686537eebf9385621bfbad8e"
 dependencies = [
- "windows-core 0.61.2",
+ "windows-core",
 "windows-link 0.1.3",
 "windows-threading",
 ]
 [[package]]
 name = "windows-implement"
 version = "0.58.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "2bbd5b46c938e506ecbce286b6628a02171d56153ba733b6c741fc627ec9579b"
 dependencies = [
 "proc-macro2",
 "quote",
 "syn 2.0.119",
 ]
 [[package]]
 name = "windows-implement"
 version = "0.60.2"
@@ -4325,17 +4427,6 @@ dependencies = [
 "syn 2.0.119",
 ]
 [[package]]
 name = "windows-interface"
 version = "0.58.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "053c4c462dc91d3b1504c6fe5a726dd15e216ba718e84a0e46a88fbe5ded3515"
 dependencies = [
 "proc-macro2",
 "quote",
 "syn 2.0.119",
 ]
 [[package]]
 name = "windows-interface"
 version = "0.59.3"
@@ -4365,19 +4456,10 @@ version = "0.2.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "9150af68066c4c5c07ddc0ce30421554771e528bde427614c61038bc2c92c2b1"
 dependencies = [
- "windows-core 0.61.2",
+ "windows-core",
 "windows-link 0.1.3",
 ]
 [[package]]
 name = "windows-result"
 version = "0.2.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "1d1043d8214f791817bab27572aaa8af63732e11bf84aa21a45a78d6c317ae0e"
 dependencies = [
 "windows-targets 0.52.6",
 ]
 [[package]]
 name = "windows-result"
 version = "0.3.4"
@@ -4387,16 +4469,6 @@ dependencies = [
 "windows-link 0.1.3",
 ]
 [[package]]
 name = "windows-strings"
 version = "0.1.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "4cd9b125c486025df0eabcb585e62173c6c9eddcec5d117d3b6e8c30e2ee4d10"
 dependencies = [
 "windows-result 0.2.0",
 "windows-targets 0.52.6",
 ]
 [[package]]
 name = "windows-strings"
 version = "0.4.2"
@@ -4657,7 +4729,7 @@ dependencies = [
 "webkit2gtk-sys",
 "webview2-com",
 "windows",
- "windows-core 0.61.2",
+ "windows-core",
 "windows-version",
 "x11-dl",
 ]
@@ -1,16 +1,56 @@
 [package]
 name = "tglock"
-version = "2.0.0-beta.1"
+version = "2.0.0-beta.5"
 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"]
 [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]
-tauri = { version = "2", features = [] }
+tauri = { version = "2", features = [], optional = true }
 open = { version = "5", optional = true }
 clap = { version = "4", features = ["derive"], optional = true }
 serde = { version = "1", features = ["derive"] }
 serde_json = "1"
-tokio = { version = "1", features = ["rt-multi-thread", "net", "io-util", "time", "macros", "sync"] }
+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"
@@ -19,11 +59,6 @@ ctr = "0.9"
 cipher = "0.4"
 sha2 = "0.10"
 rand = "0.8"
 open = "5"
 [build-dependencies]
-tauri-build = { version = "2", features = [] }
+tauri-build = { version = "2", features = [], optional = true }
 [[bin]]
 name = "tglock"
 path = "src/main.rs"
@@ -1,5 +1,11 @@
 # TGLock v2: переписал обход Telegram с нуля — теперь работает на маке, и один прокси на всю квартиру
 > **Это черновик статьи, а не документация.** Цифры в нём описывают код на
 > момент написания: «два файла, 350 строк, четыре платформы». Сейчас это 2872
 > строки Rust (из них около 1140 — тесты), семь файлов и три платформы плюс
 > headless-бинарь. Актуальное описание — [README](README.md) и
 > [docs/ARCHITECTURE_V2.md](docs/ARCHITECTURE_V2.md).
 **Простой · 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).
@@ -56,17 +56,23 @@
 ## 🤔 Что это и зачем
-TGLock — это **локальный SOCKS5-прокси** на твоём компьютере. Он перехватывает соединения Telegram, заворачивает их в WebSocket и отправляет через `web.telegram.org`. Провайдер видит обычный HTTPS — Telegram работает как раньше.
+TGLock — это **локальный прокси** на твоём компьютере: принимает и MTProto, и SOCKS5. Он перехватывает соединения Telegram, заворачивает их в WebSocket и отправляет на веб-инфраструктуру Telegram — по нескольким маршрутам сразу, переключаясь на следующий, если текущий перестал отвечать. Провайдер видит обычный HTTPS.
 **Кому подойдёт:**
- 📱 Telegram заблокировали в России или он стал открываться через раз
+- 📱 Telegram открывается через раз, сообщения уходят с задержкой, фото и видео не грузятся
 - 🐌 Голосовые/видеозвонки рвутся, сообщения уходят с задержкой, фото не грузятся
 - 🛡 GoodbyeDPI, Zapret или ByeDPI больше не помогают — провайдер шейпит **по IP**
- 🍎 Нужен инструмент для **macOS** (а на маке нет нормальных GUI-альтернатив)
+- 🍎 Нужен графический интерфейс под **macOS**
- 💻 Хочется решение для **Windows, macOS или Linux** без подписок и серверов
+- 💻 Нужно решение для **Windows, macOS или Linux** без подписок и без своего сервера
 - 🖥 Нужен вариант **для сервера или машины без монитора** — для этого есть [`tglock-cli`](#-без-графического-интерфейса-tglock-cli)
-**Чем отличается от VPN:** TGLock работает **только с Telegram**. Остальной трафик идёт напрямую — ничего не замедляется, ничего не логируется, мобильный/домашний трафик не расходуется впустую.
+**Чего TGLock не делает** — честно, чтобы не тратить твоё время:
 - ❌ **Голосовые и видеозвонки.** Они идут по UDP, а TGLock проксирует только TCP. Со звонками ничего не изменится
 - ❌ **Всё, кроме Telegram.** YouTube, Discord, Instagram, ChatGPT работать не начнут: TGLock разворачивает только MTProto — протокол, который больше нигде не используется
 - ❌ **Android и iOS.** Своего приложения нет. Телефон можно подключить к TGLock на компьютере через [LAN-режим](#-lan-режим--один-прокси-на-всю-квартиру)
 **Чем отличается от VPN:** TGLock работает **только с Telegram**. Остальной трафик идёт напрямую — ничего не замедляется, мобильный трафик не расходуется впустую.
 ---
@@ -74,11 +80,54 @@ TGLock — это **локальный SOCKS5-прокси** на твоём к
 **[👉 Последний релиз](https://github.com/by-sonic/tglock/releases/latest)**
-| Платформа | Файл | Размер |
+| Платформа | Файл |
-|---|---|---|
+|---|---|
-| **Windows 10/11** (x64) | `.exe` installer | |
+| **Windows 10/11** (x64) | `_x64-setup.exe` |
-| **macOS** (Apple Silicon + Intel) | universal `.dmg` | |
+| **macOS** (Apple Silicon + Intel) | universal `.dmg` |
-| **Linux** (x86_64) | `.AppImage` / `.deb` | |
+| **Linux** (x86_64) | `.deb` |
 | **Linux** (x86_64, портативно) | `.AppImage` |
 | **Сервер, контейнер, машина без монитора** | `tglock-cli-*` |
 Все сборки весят единицы мегабайт. Исключение — `.AppImage`: он несёт своё окружение и поэтому крупный.
 > **🖥 `tglock-cli`** — тот же туннель без графического интерфейса, одним бинарём. Нужен там, где окно не создаётся: сервер, контейнер, виртуалка, машина без монитора. Доступен начиная с `v2.0.0-beta.2`. Если ты скачал beta.2 и приложение не открывалось — это была ошибка сборки, исправлено в beta.3. Подробности — [ниже](#-без-графического-интерфейса-tglock-cli).
 ### 🛡 Антивирус ругается, SmartScreen предупреждает, VirusTotal показывает детекты
 Так и будет. Объясню механизм и дам способы проверить, не доверяя мне на слово.
 **Что ты увидишь.** На 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
@@ -104,9 +153,88 @@ Telegram → Настройки → **Продвинутые** → Тип сое
 ### 🏠 LAN-режим — один прокси на всю квартиру
-В окне TGLock включи галочку **LAN** — приложение начнёт слушать на `0.0.0.0`. Все устройства в твоей домашней сети (телефон, планшет, ноутбук, телевизор) смогут подключиться к `<твой-IP>:1080` и тоже получить рабочий Telegram. IP отобразится прямо в интерфейсе TGLock — копируй и вписывай в настройки Telegram на остальных устройствах.
+В окне TGLock включи галочку **LAN** — приложение начнёт слушать на `0.0.0.0`. Все устройства в домашней сети (телефон, планшет, ноутбук, телевизор) смогут подключиться к `<IP-компьютера>:1080` и тоже получить рабочий Telegram.
-Удобно, если дома один комп всегда включён — он становится «домашним 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                          # все флаги
 ```
 При запуске печатается готовая `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 --lan --secret-file /var/lib/tglock/secret
 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 systemctl enable --now tglock
 journalctl -u tglock -f
 ```
 `--secret-file` здесь обязателен, и это не украшение: секрет — половина `tg://proxy`-ссылки. Без файла он генерируется заново при каждом старте, и после первого же `systemctl restart` все настроенные клиенты перестанут подключаться. `StateDirectory=tglock` создаёт `/var/lib/tglock` с нужными правами, а сам файл пишется с режимом `600`.
 Остановка по `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.
 ---
@@ -115,7 +243,7 @@ Telegram → Настройки → **Продвинутые** → Тип сое
 ```
 Telegram Desktop / mobile (через LAN)
              ▼
-   SOCKS5 (127.0.0.1:1080 или 0.0.0.0:1080)
+   MTProto или SOCKS5 (127.0.0.1:1080 либо 0.0.0.0:1080)
              ▼
        TGLock — читает первые 64 байта
                 obfuscated2 init-пакета,
@@ -123,17 +251,21 @@ Telegram Desktop / mobile (через LAN)
                 достаёт номер DC
              ▼
   WSS → kws{dc}.web.telegram.org
         каскад маршрутов, см. ниже
              ▼
        Telegram Data Center
 ```
-1. **Локальный SOCKS5-прокси** перехватывает соединения Telegram Desktop.
+1. **Локальный прокси** принимает соединения Telegram: и MTProto (по ссылке `tg://proxy`), и SOCKS5.
-2. Из первых 64 байт `obfuscated2`-пакета **расшифровывается номер DC** — AES-256-CTR, ключ в байтах `[8..40]`, IV в `[40..56]`, DC ID — `i32` в `[60..64]`.
+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 в браузере.
+3. Трафик заворачивается в **WebSocket** к `kws{dc}.web.telegram.org` — это тот же домен, через который работает Telegram Web в браузере.
-4. Провайдер видит **TLS-handshake к `web.telegram.org`** — это легитимный HTTPS. DPI не видит MTProto. IP-шейпинг не работает, потому что `web.telegram.org` не блокируется в принципе.
+4. **Маршрут выбирается каскадом**, и это главное отличие 2.0 от первой версии. Один домен может резолвиться в недоступный адрес, поэтому по очереди пробуются: закреплённые IP Telegram, их дублёры `kwsN-1`, системный DNS и — если ты его настроил — твой собственный Cloudflare Worker. Упавший маршрут уходит в cooldown с удвоением задержки, удачный запоминается для этого DC. Системный DNS и файл `hosts` при этом **не изменяются**: TCP-соединение идёт на закреплённый IP, а TLS SNI и заголовок `Host` остаются настоящими, поэтому сертификат Telegram проверяется как обычно.
-5. Весь остальной трафик (не-Telegram) проходит **напрямую** — без замедления.
+5. Провайдер видит **TLS-handshake к `web.telegram.org`** — легитимный HTTPS, MTProto в нём не виден.
 6. Весь остальной трафик (не-Telegram) проходит **напрямую** — без замедления.
-📖 **Подробный технический разбор архитектуры** — см. [HABR.md](HABR.md) (≈7 мин чтения, история v1 → v2, AES-decrypt, bias `select!` для Pong, кроссплатформенная сборка).
+> Интерфейс различает три состояния и не выдаёт одно за другое: **«Защита включена»** — локальный порт открыт, туннеля пока нет; **«Ищем новый маршрут»** — попытки были неудачными, идёт перебор; **«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) — цифры там описывают код на момент написания, документацией он не является.
 ---
@@ -147,10 +279,13 @@ Telegram Desktop / mobile (через LAN)
 | Нужен сервер / подписка | ❌ | ❌ | ✅ ($) | **❌** |
 | Только Telegram | ❌ | ❌ | ❌ | **✅** |
 | LAN-шаринг | ❌ | сложно | ✅ | **✅ (галочка)** |
-| Размер | ~200 КБ | ~5 МБ | ~80 МБ | **компактное desktop-приложение** |
+| Режим без GUI | ✅ | ✅ | ❌ | **✅ (`tglock-cli`)** |
-| Цена | 0 ₽ | 0 ₽ | $3–10/мес | **0 ₽** |
+| Размер | ~200 КБ | ~5 МБ | ~80 МБ | **2 МБ установщик, 2 МБ CLI** |
 | Цена | 0 ₽ | 0 ₽ | свой сервер | **0 ₽** |
-> **⚠ Когда TGLock не подойдёт:** если заблокирован не только Telegram, а ещё YouTube, Discord, Instagram, ChatGPT, Spotify — нужен полноценный VPN. Тут поможет **[🌹 RoseVPN](https://t.me/rosevpnru_bot)** (см. блок ниже).
+> **⚠ Когда TGLock не подойдёт:** если заблокирован не только Telegram, а ещё YouTube, Discord, Instagram или ChatGPT — обходить каждый сервис отдельно смысла нет, нужен полноценный VPN. TGLock эту задачу не решает и решать не будет: он разворачивает только MTProto.
 >
 > Звонки тоже не заработают — они по UDP, а TGLock проксирует только TCP.
 ---
@@ -159,13 +294,17 @@ Telegram Desktop / mobile (через LAN)
 <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 к `web.telegram.org`, который не блокируется.
+Полностью 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 в браузере. Кода ~350 строк, всё открыто на GitHub — можно прочитать и собрать самому.
+TGLock — **локальный прокси**. Он работает только на твоём компьютере и не отправляет данные третьим сторонам. Соединение идёт к серверам Telegram через их же домен `web.telegram.org` — тот же, что использует Telegram Web в браузере. Единственное исключение — если ты сам укажешь в настройках свой Cloudflare Worker как резервный маршрут; по умолчанию это поле пустое, и никакой сторонней инфраструктуры в схеме нет.
 Кода — около 2900 строк Rust (из них ~1100 приходится на тесты) и ~380 строк TypeScript на интерфейс. Всё открыто, можно прочитать и собрать самому. Бинарники в релизах собираются из этого же исходника в GitHub Actions — логи сборки публичные.
 </details>
 <details>
@@ -173,15 +312,18 @@ TGLock — **локальный прокси**. Он работает тольк
 GoodbyeDPI, Zapret и ByeDPI **фрагментируют пакеты**, чтобы DPI не распознал MTProto. Это работает, пока провайдер блокирует *по содержимому*. Но если шейпинг идёт **по IP** (а так делают большинство крупных РФ-провайдеров с 2024–2026 — Ростелеком, МТС, Билайн, Мегафон), фрагментация не помогает: пакеты всё равно идут на «нехороший» IP и троттлятся.
-TGLock же отправляет трафик на **`web.telegram.org`** — обычный HTTPS-домен, который не блокируется в принципе.
+TGLock же отправляет трафик на **`web.telegram.org`** — обычный HTTPS-домен, который под IP-шейпинг Telegram DC не попадает.
 </details>
 <details>
 <summary><b>Работает ли на iPhone или Android?</b></summary>
-Напрямую — нет, TGLock сам по себе только для desktop. Но если включить **LAN-режим** на компьютере, в настройках Telegram на телефоне можно указать SOCKS5-прокси с IP компа. Telegram на мобиле начнёт ходить через ПК. Удобно, если дома один компьютер всегда включён.
+Своего приложения под Android и iOS нет — TGLock только для desktop. Есть два обходных пути:
-Для полностью мобильного решения нужен VPN — например, **[🌹 RoseVPN](https://t.me/rosevpnru_bot)** с приложением Karing для iOS/Android.
+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>
@@ -193,11 +335,10 @@ TGLock же отправляет трафик на **`web.telegram.org`** — о
 <details>
 <summary><b>Apple ругается «приложение не проверено / нельзя открыть»</b></summary>
-Подпись Apple Developer ID стоит $99 в год — для бесплатного open-source это перебор. Сними блокировку Gatekeeper руками — открой Терминал и выполни:
+Сборка пока не подписана и не нотарифицирована — Apple Developer ID стоит $99 в год. Сними карантин Gatekeeper руками: перенеси приложение из `.dmg` в «Программы» и выполни в Терминале
 ```bash
-xattr -cr ~/Downloads/tglock-macos-arm64
+xattr -cr /Applications/TGLock.app
 chmod +x ~/Downloads/tglock-macos-arm64
 ```
 После этого приложение запустится двойным кликом из Finder.
@@ -214,6 +355,16 @@ chmod +x ~/Downloads/tglock-macos-arm64
 - На 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>
@@ -223,19 +374,31 @@ chmod +x ~/Downloads/tglock-macos-arm64
 <details>
 <summary><b>А что если провайдер заблокирует и <code>web.telegram.org</code>?</b></summary>
-Тогда TGLock перестанет работать у этого конкретного провайдера. Но **публичная блокировка веб-версии Telegram** — это большой шаг, и Роскомнадзор пока на него не идёт. Если всё же случится — используй **[🌹 RoseVPN](https://t.me/rosevpnru_bot)**, там домен фронтирования автоматически меняется (SNI rotation, Reality), и пробивает даже агрессивный DPI.
+Это реальный риск, и 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 только его. Остальное идёт напрямую — без шифрования и аутентификации, как обычный SOCKS5-релей. Для других приложений возьми правильный SOCKS5-сервер (или VPN).
+Смысла нет, и по умолчанию это запрещено.
 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 автоматически собирает бинарники для всех 4 платформ и публикует. Подпишись на репозиторий (кнопка **Watch** → **Custom** → **Releases**), чтобы получать уведомления о новых версиях.
+Все релизы — на странице **[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>
 ---
@@ -245,11 +408,14 @@ chmod +x ~/Downloads/tglock-macos-arm64
 | Технология | Зачем |
 |---|---|
 | **Rust** | Один бинарник, нативная скорость, без runtime-зависимостей |
-| **Tauri 2** | Нативная кроссплатформенная оболочка с современным web-интерфейсом |
+| **Tauri 2** | Нативная оболочка для GUI. Опциональна: за фичей `gui`, в CLI не входит |
 | **TypeScript + Vite** | Интерфейс, внутренняя навигация и строгая типизация |
-| **tokio** | Async I/O для тысяч одновременных соединений |
+| **tokio** | Async I/O, обработка сигналов для корректной остановки сервиса |
 | **tokio-tungstenite** | WebSocket-клиент с TLS поверх `native-tls` |
 | **aes** + **ctr** | Расшифровка MTProto `obfuscated2` init-пакета |
 | **clap** | Разбор аргументов `tglock-cli` |
 Ядро (`src/lib.rs`: разбор MTProto, каскад маршрутов, прокси) не зависит ни от Tauri, ни от оконной системы — поэтому один и тот же код обслуживает и графический интерфейс, и headless-режим.
 ---
@@ -262,34 +428,46 @@ npm ci
 npm run tauri build
 ```
-Результат — `target/release/tglock` (или `tglock.exe` на Windows). Требуется Rust **stable 1.75+**.
+Результат — `target/release/tglock` (или `tglock.exe` на Windows).
-### Кросс-компиляция через GitHub Actions
+Минимальная версия Rust — **1.88** (`rust-version` в `Cargo.toml`, проверяется отдельной задачей в CI). На более старых тулчейнах зависимости не соберутся: часть из них требует edition 2024.
-Хочешь собрать свой релиз? Форкни репозиторий, поставь тег `v1.0.1`, и `.github/workflows/release.yml` сам соберёт бинарники под Windows x64, macOS ARM64, macOS Intel и Linux x64.
+### Только CLI, без графики
 ```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` под те же три платформы, и опубликует их в релизе.
 ---
-## 🌹 Нужен VPN на всё подряд?
+## 🤝 Как помочь
-Если у тебя заблокирован **не только Telegram**, а ещё YouTube, Discord, Instagram, ChatGPT, Spotify — обходить каждое приложение отдельно нет смысла. Возьми VPN, который умеет всё сразу.
+Проект живой, PR и баг-репорты разбираются.
-<p align="center">
+- **Нашёл баг** — [открой issue](https://github.com/by-sonic/tglock/issues/new). Полезнее всего: ОС и версия, что показывает вкладка диагностики (маршрут, DC, число сбоев) и провайдер. Для `tglock-cli` — вывод из консоли.
-  <a href="https://t.me/rosevpnru_bot">
+- **Хочешь фичу** — тоже issue. Если её нет в планах, так и будет написано, без месяцев тишины.
-    <img alt="Подключить RoseVPN — Telegram-бот" src="https://img.shields.io/badge/%F0%9F%8C%B9%20RoseVPN-%D0%9F%D0%BE%D0%B4%D0%BA%D0%BB%D1%8E%D1%87%D0%B8%D1%82%D1%8C%20%D0%B2%20Telegram-E63946?style=for-the-badge&logo=telegram&logoColor=white&labelColor=0a0a0a" height="40"/>
+- **Присылаешь PR** — перед отправкой прогони проверки выше, они те же, что в CI. Небольшие PR ревьюятся быстрее.
-  </a>
+- **Не работает после релиза** — это регрессия, пиши сразу, такие вещи в приоритете.
 </p>
-**Что внутри RoseVPN:**
+Известные ограничения, о которых не нужно открывать issue: звонки (UDP), сервисы кроме Telegram (только MTProto), Android и iOS (обсуждается в [#9](https://github.com/by-sonic/tglock/issues/9)).
 - 🔥 **Hysteria2 + VLESS-Reality fallback** — обходит TSPU и агрессивный DPI
 - 🛡 **Без логов трафика** — приватность по умолчанию
 - 🎁 **Бесплатный пробный период** — без карты, без регистрации
 - 📱 **Karing-клиент** с автонастройкой — установка в 2 тапа
 - 💻 **Windows, macOS, iOS, Android** — везде нативные приложения
 - 🔄 **SNI-ротация** на случай новых блокировок
 Подключение — через Telegram-бот **[@rosevpnru_bot](https://t.me/rosevpnru_bot)**.
 ---
@@ -300,5 +478,5 @@ npm run tauri build
 ---
 <p align="center">
-  <sub><b>by sonic</b> · <a href="https://t.me/rosevpnru_bot">@rosevpnru_bot</a> · <a href="https://github.com/by-sonic/tglock/issues">Issues & feedback</a></sub>
+  <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>
@@ -1,3 +1,7 @@
 fn main() {
-    tauri_build::build()
+    // 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();
 }
@@ -1,5 +1,23 @@
 # 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-порт автоматически принимает два типа клиентов:
@@ -12,6 +30,44 @@ MTProto init проверяется по secret и transport tag. Из него
 стандартный 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-соединений строится список маршрутов:
@@ -55,6 +111,21 @@ Worker должен принимать WebSocket на:
 - 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-соединений будут добавлены после измерения,
@@ -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), поправлю.
@@ -3,6 +3,44 @@
 Проверено 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 не работает» — приложение
@@ -1,7 +1,7 @@
 {
  "name": "tglock-ui",
  "private": true,
-  "version": "2.0.0-beta.1",
+  "version": "2.0.0-beta.5",
  "type": "module",
  "scripts": {
    "dev": "vite --port 1420",
@@ -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))
@@ -0,0 +1,333 @@
 //! 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::config::ListenConfig;
 use tglock::{mtproto, proxy, transport};
 const STATUS_POLL: Duration = Duration::from_secs(1);
 #[derive(Debug, Parser)]
 #[command(
    name = "tglock-cli",
    version,
    about = "TGLock без графического интерфейса: локальный MTProto-прокси через WebSocket"
 )]
 struct Args {
    /// Адрес для прослушивания. 127.0.0.1 — только этот компьютер
    #[arg(short, long, value_name = "IP", default_value = "127.0.0.1")]
    bind: IpAddr,
    /// Порт локального прокси
    #[arg(short, long, value_name = "PORT", default_value_t = proxy::DEFAULT_PORT)]
    port: 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,
    /// Файл с секретом прокси. Обязателен для сервиса: иначе после перезапуска
    /// секрет будет новым и уже настроенные клиенты перестанут подключаться
    #[arg(long, value_name = "PATH")]
    secret_file: Option<PathBuf>,
    /// Печатать только ошибки
    #[arg(short, long)]
    quiet: bool,
 }
 impl Args {
    fn stats(&self) -> Arc<proxy::Stats> {
        match &self.secret_file {
            Some(path) => proxy::Stats::with_secret(mtproto::load_or_create_secret_at(path)),
            None => proxy::Stats::new(),
        }
    }
    fn listen(&self) -> ListenConfig {
        let base = if self.lan {
            ListenConfig::lan(self.port)
        } else {
            ListenConfig::new(self.bind, self.port)
        };
        if self.allow_direct {
            base.with_allow_direct(true)
        } else {
            base
        }
    }
    fn worker_domains(&self) -> String {
        self.worker.join(",")
    }
 }
 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 listen = args.listen();
    let stats = args.stats();
    stats.set_worker_domain(&args.worker_domains());
    // 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 !args.quiet {
        println!("Слушаю {}", listen.addr);
        println!(
            "Ссылка для Telegram: {}",
            listen.telegram_link(&stats.telegram_secret())
        );
        if listen.allow_direct && !listen.addr.ip().is_loopback() {
            println!(
                "Внимание: --allow-direct на адресе {} превращает TGLock в открытый SOCKS5-прокси",
                listen.addr.ip()
            );
        } else if !listen.allow_direct {
            println!("Пропускаю только адреса Telegram");
        }
        if !args.worker.is_empty() {
            println!("Резервные Worker-домены: {}", args.worker_domains());
        }
    }
    let server_stats = stats.clone();
    let mut server =
        tokio::spawn(
            async move { proxy::serve(server_stats, listener, listen.allow_direct).await },
        );
    let watcher = (!args.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 !args.quiet {
                println!("Получен сигнал остановки, закрываю соединения…");
            }
            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;
        println!(
            "соединений {active} · туннелей {tunnels} · {} · {} · сбоев {failures}",
            if dc > 0 {
                format!("DC{dc}")
            } else {
                "DC не определён".to_owned()
            },
            transport::route_label(route)
        );
        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()
    }
    #[test]
    fn command_definition_is_valid() {
        Args::command().debug_assert();
    }
    #[test]
    fn defaults_to_loopback_on_the_default_port() {
        let listen = parse(&[]).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!(
            parse(&["--lan"]).listen(),
            parse(&["-b", "0.0.0.0"]).listen()
        );
    }
    #[test]
    fn lan_does_not_relay_non_telegram_traffic() {
        let listen = parse(&["--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!(!parse(&["-b", "192.168.1.10"]).listen().allow_direct);
        assert!(
            parse(&["-b", "192.168.1.10", "--allow-direct"])
                .listen()
                .allow_direct
        );
    }
    #[test]
    fn bind_and_port_are_honoured() {
        let listen = parse(&["--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 = parse(&["-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 args = parse(&["--worker", "a.workers.dev", "--worker", "b.workers.dev"]);
        assert_eq!(args.worker_domains(), "a.workers.dev,b.workers.dev");
    }
    #[test]
    fn no_worker_flag_means_no_domains() {
        assert!(parse(&[]).worker_domains().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 = parse(&["--secret-file", path.to_str().unwrap()])
            .stats()
            .telegram_secret();
        let second = parse(&["--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 = parse(&["--secret-file", path.to_str().unwrap()])
            .stats()
            .telegram_secret();
        assert_ne!(third, first);
        let fourth = parse(&["--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"
            );
        }
    }
 }
@@ -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());
    }
 }
@@ -0,0 +1,11 @@
 //! 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;
@@ -1,15 +1,13 @@
 #![cfg_attr(not(debug_assertions), windows_subsystem = "windows")]
 mod mtproto;
 mod proxy;
 mod transport;
 use serde::{Deserialize, Serialize};
 use std::path::PathBuf;
 use std::sync::atomic::Ordering;
 use std::sync::{Arc, Mutex};
 use std::time::{Instant, SystemTime, UNIX_EPOCH};
 use tauri::{Manager, State};
 use tglock::config::ListenConfig;
 use tglock::{proxy, transport};
 #[derive(Clone, Debug, Deserialize, Serialize)]
 #[serde(rename_all = "camelCase")]
@@ -90,11 +88,7 @@ impl AppState {
    fn snapshot(&self) -> StatusSnapshot {
        let data_center = self.stats.last_dc.load(Ordering::Relaxed);
-        let route = match self.stats.last_route.load(Ordering::Relaxed) {
+        let route = transport::route_label(self.stats.last_route.load(Ordering::Relaxed));
            1 => "Telegram WebSocket",
            2 => "Cloudflare Worker",
            _ => "Автоматический маршрут",
        };
        StatusSnapshot {
            running: self.stats.running.load(Ordering::SeqCst),
            active_connections: self.stats.active.load(Ordering::Relaxed),
@@ -173,10 +167,14 @@ fn start_proxy(state: State<'_, AppState>) -> Result<StatusSnapshot, String> {
    *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();
    let lan_mode = settings.lan_mode;
    let port = settings.port;
    std::thread::spawn(move || {
        let runtime = match tokio::runtime::Runtime::new() {
            Ok(runtime) => runtime,
@@ -185,7 +183,7 @@ fn start_proxy(state: State<'_, AppState>) -> Result<StatusSnapshot, String> {
                return;
            }
        };
-        if let Err(error) = runtime.block_on(proxy::run(stats, lan_mode, port)) {
+        if let Err(error) = runtime.block_on(proxy::run(stats, listen)) {
            push_log(&logs, format!("Ошибка подключения: {error}"), true);
        }
    });
@@ -202,28 +200,8 @@ fn start_proxy(state: State<'_, AppState>) -> Result<StatusSnapshot, String> {
            .unwrap_or_else(|| "Не удалось запустить прокси".into()));
    }
-    state.log(
+    state.log(format!("Прокси запущен на {}", listen.addr), false);
-        format!(
+    let _ = open::that(listen.telegram_link(&state.stats.telegram_secret()));
            "Прокси запущен на {}:{}",
            if settings.lan_mode {
                "0.0.0.0"
            } else {
                "127.0.0.1"
            },
            settings.port
        ),
        false,
    );
    let host = if settings.lan_mode {
        local_ip().unwrap_or_else(|| "127.0.0.1".into())
    } else {
        "127.0.0.1".into()
    };
    let _ = open::that(format!(
        "tg://proxy?server={host}&port={}&secret={}",
        settings.port,
        state.stats.telegram_secret()
    ));
    state.log("Открываю подключение в Telegram…", false);
    Ok(state.snapshot())
 }
@@ -244,13 +222,56 @@ fn push_log(logs: &Arc<Mutex<Vec<LogLine>>>, message: String, error: bool) {
    });
 }
-fn local_ip() -> Option<String> {
+/// Environment variables that make the WebView render without a GPU.
-    let socket = std::net::UdpSocket::bind("0.0.0.0:0").ok()?;
+///
-    socket.connect("8.8.8.8:80").ok()?;
+/// The window is never created when 3D acceleration is unavailable: no
-    Some(socket.local_addr().ok()?.ip().to_string())
+/// 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();
    }
    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()
 }
 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
@@ -271,3 +292,50 @@ fn main() {
        .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"
            );
        }
    }
    #[test]
    fn force_gpu_disables_the_override() {
        assert!(software_rendering_vars(true, |_| false).is_empty());
    }
    #[test]
    fn an_operators_own_value_is_never_overwritten() {
        assert!(software_rendering_vars(false, |_| true).is_empty());
    }
    #[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"
                ]
            );
        }
    }
 }
@@ -2,6 +2,7 @@ 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;
@@ -50,12 +51,13 @@ pub fn generate_secret() -> [u8; 16] {
    secret
 }
-#[cfg(not(test))]
+/// Reuse the secret stored at `path`, creating it if it is missing or unusable.
-pub fn load_or_create_secret() -> [u8; 16] {
+///
-    let Some(path) = secret_path() else {
+/// A daemon needs this: the secret is half of the `tg://proxy` link, so a
-        return generate_secret();
+/// service that invents a new one on every restart silently invalidates every
-    };
+/// client that was already configured.
-    if let Ok(value) = std::fs::read_to_string(&path) {
+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;
        }
@@ -65,10 +67,18 @@ pub fn load_or_create_secret() -> [u8; 16] {
    if let Some(parent) = path.parent() {
        let _ = std::fs::create_dir_all(parent);
    }
-    write_secret_file(&path, &secret_hex(&secret));
+    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")]
@@ -94,8 +104,8 @@ fn secret_path() -> Option<PathBuf> {
    }
 }
-#[cfg(all(not(test), unix))]
+#[cfg(unix)]
-fn write_secret_file(path: &std::path::Path, value: &str) {
+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()
@@ -109,8 +119,8 @@ fn write_secret_file(path: &std::path::Path, value: &str) {
    }
 }
-#[cfg(all(not(test), not(unix)))]
+#[cfg(not(unix))]
-fn write_secret_file(path: &std::path::Path, value: &str) {
+fn write_secret_file(path: &Path, value: &str) {
    let _ = std::fs::write(path, value);
 }
@@ -255,6 +265,66 @@ pub(crate) fn test_client_init(secret: &[u8; 16], dc_index: i16) -> [u8; INIT_LE
    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::*;
@@ -304,6 +374,133 @@ mod tests {
        );
    }
    #[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 parses_persisted_secret() {
        assert_eq!(
@@ -1,3 +1,4 @@
 use crate::config::ListenConfig;
 use std::net::Ipv4Addr;
 use std::sync::atomic::{AtomicBool, AtomicU16, AtomicU32, AtomicU8, Ordering};
 use std::sync::{Arc, Mutex};
@@ -8,6 +9,12 @@ use tokio_tungstenite::tungstenite;
 pub const DEFAULT_PORT: u16 = 1080;
 const IO_TIMEOUT: Duration = Duration::from_secs(10);
 const INIT_LEN: usize = 64;
 const SOCKS5_VERSION: u8 = 0x05;
 /// How long to wait for a full MTProto init before treating an ambiguous first
 /// byte as the start of a SOCKS5 greeting.
 const PROTOCOL_PROBE_TIMEOUT: Duration = Duration::from_millis(250);
 const PROTOCOL_PROBE_INTERVAL: Duration = Duration::from_millis(5);
 pub struct Stats {
    pub running: AtomicBool,
@@ -25,6 +32,14 @@ pub struct Stats {
 impl Stats {
    pub fn new() -> Arc<Self> {
        Self::with_secret(initial_secret())
    }
    /// Build with an explicit proxy secret.
    ///
    /// A daemon must pin this: the secret is half of the `tg://proxy` link, so
    /// generating a fresh one on restart breaks every configured client.
    pub fn with_secret(secret: [u8; 16]) -> Arc<Self> {
        Arc::new(Self {
            running: AtomicBool::new(false),
            active: AtomicU32::new(0),
@@ -34,7 +49,7 @@ impl Stats {
            ws_failures: AtomicU32::new(0),
            last_route: AtomicU8::new(0),
            transport: crate::transport::TransportEngine::new(),
-            secret: initial_secret(),
+            secret,
            shutdown: Mutex::new(None),
        })
    }
@@ -69,13 +84,28 @@ fn initial_secret() -> [u8; 16] {
    crate::mtproto::generate_secret()
 }
-pub async fn run(stats: Arc<Stats>, lan: bool, port: u16) -> Result<(), String> {
+/// Claim the local port.
-    let host = if lan { "0.0.0.0" } else { "127.0.0.1" };
+///
-    let addr = format!("{}:{}", host, port);
+/// Separated from [`serve`] so a caller can report a port conflict before it
-    let listener = TcpListener::bind(&addr)
+/// tells the user the proxy is running.
 pub async fn bind(listen: ListenConfig) -> Result<TcpListener, String> {
    TcpListener::bind(listen.addr)
        .await
-        .map_err(|e| format!("Port {} busy: {}", port, e))?;
+        .map_err(|error| format!("Cannot listen on {}: {}", listen.addr, error))
 }
 /// Bind and serve until [`Stats::stop`] is called.
 pub async fn run(stats: Arc<Stats>, listen: ListenConfig) -> Result<(), String> {
    let listener = bind(listen).await?;
    serve(stats, listener, listen.allow_direct).await
 }
 /// Accept clients on an already bound listener.
 pub async fn serve(
    stats: Arc<Stats>,
    listener: TcpListener,
    allow_direct: bool,
 ) -> Result<(), String> {
    stats.running.store(true, Ordering::SeqCst);
    let (shutdown_tx, mut shutdown_rx) = tokio::sync::watch::channel(false);
    *stats.shutdown.lock().unwrap() = Some(shutdown_tx);
@@ -90,7 +120,7 @@ pub async fn run(stats: Arc<Stats>, lan: bool, port: u16) -> Result<(), String>
                        s.active.fetch_add(1, Ordering::Relaxed);
                        s.total.fetch_add(1, Ordering::Relaxed);
                        tasks.spawn(async move {
-                            let _ = handle(stream, &s, !lan).await;
+                            let _ = handle(stream, &s, allow_direct).await;
                            s.active.fetch_sub(1, Ordering::Relaxed);
                        });
                    }
@@ -115,22 +145,67 @@ pub async fn run(stats: Arc<Stats>, lan: bool, port: u16) -> Result<(), String>
 // -- SOCKS5 -----------------------------------------------------------------
 #[derive(Debug, Eq, PartialEq)]
 enum Protocol {
    Socks5,
    MtProto,
    Empty,
 }
 async fn handle(
    s: TcpStream,
    stats: &Stats,
    allow_direct: bool,
 ) -> Result<(), Box<dyn std::error::Error + Send + Sync>> {
-    let mut first = [0; 1];
+    match detect_protocol(&s, stats).await? {
-    let peeked = tokio::time::timeout(IO_TIMEOUT, s.peek(&mut first))
+        Protocol::Socks5 => handle_socks5(s, stats, allow_direct).await,
        Protocol::MtProto => handle_mtproto(s, stats).await,
        Protocol::Empty => Ok(()),
    }
 }
 /// Decide which protocol a fresh client is speaking without consuming anything.
 ///
 /// A SOCKS5 greeting starts with `0x05` — but so does one in every 256 MTProto
 /// init packets, because the client fills those 64 bytes at random and
 /// `mtproto::is_reserved_init` only avoids `0xef`, `0xee`, `0xdd`, HTTP verbs
 /// and the TLS record header. Deciding on the first byte alone therefore sends
 /// roughly one connection in 256 down the SOCKS5 path, where it dies. From the
 /// outside that looks exactly like Telegram sending messages every other try.
 ///
 /// When the first byte is ambiguous, wait briefly: a real SOCKS5 client sends a
 /// short greeting and then blocks on our reply, so only MTProto produces a full
 /// 64-byte init that decodes under our secret.
 async fn detect_protocol(
    stream: &TcpStream,
    stats: &Stats,
 ) -> Result<Protocol, Box<dyn std::error::Error + Send + Sync>> {
    let mut probe = [0; INIT_LEN];
    let peeked = tokio::time::timeout(IO_TIMEOUT, stream.peek(&mut probe[..1]))
        .await
        .map_err(|_| "client protocol detection timeout")??;
    if peeked == 0 {
-        return Ok(());
+        return Ok(Protocol::Empty);
    }
-    if first[0] == 0x05 {
+    if probe[0] != SOCKS5_VERSION {
-        handle_socks5(s, stats, allow_direct).await
+        return Ok(Protocol::MtProto);
-    } else {
+    }
-        handle_mtproto(s, stats).await
+
    let deadline = tokio::time::Instant::now() + PROTOCOL_PROBE_TIMEOUT;
    loop {
        if stream.peek(&mut probe).await? == INIT_LEN {
            return Ok(
                if crate::mtproto::parse_client_init(&probe, &stats.secret).is_some() {
                    Protocol::MtProto
                } else {
                    Protocol::Socks5
                },
            );
        }
        if tokio::time::Instant::now() >= deadline {
            return Ok(Protocol::Socks5);
        }
        tokio::time::sleep(PROTOCOL_PROBE_INTERVAL).await;
    }
 }
@@ -167,11 +242,9 @@ async fn handle_socks5(
        });
        stats.last_dc.store(dc, Ordering::Relaxed);
        stats.ws.fetch_add(1, Ordering::Relaxed);
        let r = ws_tunnel(s, dc, media, &init, None, stats).await;
        stats.ws.fetch_sub(1, Ordering::Relaxed);
        if r.is_err() {
            stats.ws_failures.fetch_add(1, Ordering::Relaxed);
        }
@@ -199,7 +272,6 @@ async fn handle_mtproto(
        .ok_or("invalid MTProto init or secret")?;
    stats.last_dc.store(parsed.dc, Ordering::Relaxed);
    stats.ws.fetch_add(1, Ordering::Relaxed);
    let result = ws_tunnel(
        stream,
        parsed.dc,
@@ -209,7 +281,6 @@ async fn handle_mtproto(
        stats,
    )
    .await;
    stats.ws.fetch_sub(1, Ordering::Relaxed);
    if result.is_err() {
        stats.ws_failures.fetch_add(1, Ordering::Relaxed);
    }
@@ -326,6 +397,28 @@ fn dc_from_ip(ip: Ipv4Addr) -> Option<u16> {
 // -- WebSocket tunnel -------------------------------------------------------
 /// Keeps `Stats::ws` equal to the number of *established* tunnels.
 ///
 /// Counting attempts instead would let the interface announce «Telegram на
 /// связи» while the WebSocket handshake is still failing over between routes,
 /// which takes seconds per route. Reporting a working tunnel that does not
 /// exist yet is the whole reason users saw «прокси подключён, а Telegram не
 /// работает».
 struct EstablishedTunnel<'a>(&'a Stats);
 impl<'a> EstablishedTunnel<'a> {
    fn new(stats: &'a Stats) -> Self {
        stats.ws.fetch_add(1, Ordering::Relaxed);
        Self(stats)
    }
 }
 impl Drop for EstablishedTunnel<'_> {
    fn drop(&mut self) {
        self.0.ws.fetch_sub(1, Ordering::Relaxed);
    }
 }
 async fn ws_tunnel(
    tcp: TcpStream,
    dc: u16,
@@ -337,6 +430,7 @@ async fn ws_tunnel(
    use futures_util::{SinkExt, StreamExt};
    let (mut ws, connected) = stats.transport.connect(dc, media).await?;
    let _tunnel = EstablishedTunnel::new(stats);
    stats
        .last_route
        .store(connected.route.kind.ui_code(), Ordering::Relaxed);
@@ -397,6 +491,139 @@ async fn tcp_relay(a: TcpStream, b: TcpStream) {
 mod tests {
    use super::*;
    use tokio::io::{AsyncReadExt, AsyncWriteExt};
    use tokio_tungstenite::tungstenite::handshake::server::{Request, Response};
    use tokio_tungstenite::tungstenite::Message;
    /// Start the proxy on a kernel-assigned port.
    ///
    /// Binding first and reading the port back removes the reserve-then-rebind
    /// race that a `port 0` helper would otherwise introduce.
    async fn start_proxy(
        stats: Arc<Stats>,
        allow_direct: bool,
    ) -> (u16, tokio::task::JoinHandle<Result<(), String>>) {
        let listener = bind(ListenConfig::loopback(0)).await.unwrap();
        let port = listener.local_addr().unwrap().port();
        let server = tokio::spawn(async move { serve(stats, listener, allow_direct).await });
        (port, server)
    }
    async fn wait_until(label: &str, mut condition: impl FnMut() -> bool) {
        tokio::time::timeout(Duration::from_secs(5), async {
            while !condition() {
                tokio::time::sleep(Duration::from_millis(2)).await;
            }
        })
        .await
        .unwrap_or_else(|_| panic!("timed out waiting for {label}"));
    }
    /// Perform a SOCKS5 greeting, send `request`, return the 10-byte reply.
    async fn socks5_exchange(port: u16, request: &[u8]) -> (TcpStream, [u8; 10]) {
        let mut client = TcpStream::connect(("127.0.0.1", port)).await.unwrap();
        client.write_all(&[0x05, 0x01, 0x00]).await.unwrap();
        let mut greeting = [0; 2];
        client.read_exact(&mut greeting).await.unwrap();
        assert_eq!(greeting, [0x05, 0x00]);
        client.write_all(request).await.unwrap();
        let mut reply = [0; 10];
        client.read_exact(&mut reply).await.unwrap();
        (client, reply)
    }
    fn socks5_ipv4_request(command: u8, ip: [u8; 4], port: u16) -> Vec<u8> {
        let mut request = vec![0x05, command, 0x00, 0x01];
        request.extend_from_slice(&ip);
        request.extend_from_slice(&port.to_be_bytes());
        request
    }
    /// A client init whose first byte is not the SOCKS5 version, so the test
    /// exercises the unambiguous detection path.
    fn unambiguous_client_init(secret: &[u8; 16], dc_index: i16) -> [u8; INIT_LEN] {
        loop {
            let init = crate::mtproto::test_client_init(secret, dc_index);
            if init[0] != SOCKS5_VERSION {
                return init;
            }
        }
    }
    fn ambiguous_client_init(secret: &[u8; 16], dc_index: i16) -> [u8; INIT_LEN] {
        loop {
            let init = crate::mtproto::test_client_init(secret, dc_index);
            if init[0] == SOCKS5_VERSION {
                return init;
            }
        }
    }
    /// Stand-in for `kwsN.web.telegram.org`: a plaintext WebSocket that behaves
    /// like an obfuscated2 relay.
    ///
    /// Returns the URI it was asked for, the raw init frame it was handed and
    /// the plaintext it recovered, so a test can assert on what Telegram — or a
    /// Cloudflare Worker standing in for it — would really have seen.
    // The handshake callback's error type is tungstenite's own `ErrorResponse`,
    // whose size is not ours to change.
    #[allow(clippy::result_large_err)]
    async fn mock_relay(
        listener: TcpListener,
        response: Vec<u8>,
    ) -> Result<(String, Vec<u8>, Vec<u8>), String> {
        use futures_util::{SinkExt, StreamExt};
        let (tcp, _) = listener.accept().await.map_err(|e| e.to_string())?;
        let requested = Arc::new(Mutex::new(String::new()));
        let seen = requested.clone();
        // Telegram confirms the `binary` subprotocol the proxy asks for, and
        // tungstenite refuses a handshake that silently drops it. A mock that
        // does not answer it would only ever test the failure path.
        let mut websocket = tokio_tungstenite::accept_hdr_async(
            tcp,
            move |request: &Request, mut response: Response| {
                *seen.lock().unwrap() = request.uri().to_string();
                response.headers_mut().insert(
                    "Sec-WebSocket-Protocol",
                    "binary".parse().expect("static header value"),
                );
                Ok(response)
            },
        )
        .await
        .map_err(|e| e.to_string())?;
        let requested = requested.lock().unwrap().clone();
        let init = match websocket.next().await {
            Some(Ok(Message::Binary(data))) => data,
            other => return Err(format!("expected an init frame, got {other:?}")),
        };
        let header: [u8; INIT_LEN] = init
            .as_slice()
            .try_into()
            .map_err(|_| format!("init frame is {} bytes, not {INIT_LEN}", init.len()))?;
        let mut relay = crate::mtproto::test_relay_peer(&header);
        let mut request = Vec::new();
        while request.is_empty() {
            match websocket.next().await {
                Some(Ok(Message::Binary(mut data))) => {
                    relay.decrypt(&mut data);
                    request.extend_from_slice(&data);
                }
                Some(Ok(_)) => {}
                _ => break,
            }
        }
        let mut wire = response;
        relay.encrypt(&mut wire);
        websocket
            .send(Message::Binary(wire))
            .await
            .map_err(|e| e.to_string())?;
        Ok((requested, init, request))
    }
    #[tokio::test]
    async fn parses_fragmented_ipv4_socks5_handshake() {
@@ -451,7 +678,8 @@ mod tests {
        let stats = Stats::new();
        let server_stats = stats.clone();
-        let server = tokio::spawn(async move { run(server_stats, false, port).await });
+        let server =
            tokio::spawn(async move { run(server_stats, ListenConfig::loopback(port)).await });
        tokio::time::timeout(Duration::from_secs(2), async {
            while !stats.running.load(Ordering::SeqCst) {
@@ -470,6 +698,359 @@ mod tests {
        assert!(!stats.running.load(Ordering::SeqCst));
    }
    #[tokio::test]
    async fn parses_domain_and_ipv6_socks5_targets() {
        let domain = "web.telegram.org";
        let mut domain_payload = vec![u8::try_from(domain.len()).unwrap()];
        domain_payload.extend_from_slice(domain.as_bytes());
        for (address_type, payload, expected) in
            [(0x03_u8, domain_payload, domain), (0x04, vec![0; 16], "::")]
        {
            let (mut client, mut server) = tokio::io::duplex(256);
            let task = tokio::spawn(async move { read_socks5_request(&mut server).await.unwrap() });
            client.write_all(&[0x05, 0x01, 0x00]).await.unwrap();
            let mut greeting = [0; 2];
            client.read_exact(&mut greeting).await.unwrap();
            let mut request = vec![0x05, 0x01, 0x00, address_type];
            request.extend_from_slice(&payload);
            request.extend_from_slice(&443_u16.to_be_bytes());
            client.write_all(&request).await.unwrap();
            assert_eq!(task.await.unwrap(), (expected.to_owned(), 443));
        }
    }
    #[tokio::test]
    async fn rejects_malformed_and_unsupported_socks5_requests() {
        // (request after the greeting, expected reply status, why)
        let cases: [(Vec<u8>, Option<u8>, &str); 5] = [
            (
                vec![0x05, 0x03, 0x00, 0x01, 1, 1, 1, 1, 0x01, 0xbb],
                Some(0x07),
                "UDP ASSOCIATE is not implemented, so it must be refused rather than half-served",
            ),
            (
                vec![0x05, 0x02, 0x00, 0x01, 1, 1, 1, 1, 0x01, 0xbb],
                Some(0x07),
                "BIND is not implemented",
            ),
            (
                vec![0x05, 0x01, 0x00, 0x09, 1, 1, 1, 1, 0x01, 0xbb],
                Some(0x08),
                "unknown address type",
            ),
            (
                vec![0x05, 0x01, 0x00, 0x03, 0x00, 0x01, 0xbb],
                None,
                "empty domain",
            ),
            (
                vec![0x04, 0x01, 0x00, 0x01, 1, 1, 1, 1, 0x01, 0xbb],
                None,
                "wrong protocol version in the request",
            ),
        ];
        for (request, expected_status, reason) in cases {
            let (mut client, mut server) = tokio::io::duplex(256);
            let task = tokio::spawn(async move { read_socks5_request(&mut server).await.is_err() });
            client.write_all(&[0x05, 0x01, 0x00]).await.unwrap();
            let mut greeting = [0; 2];
            client.read_exact(&mut greeting).await.unwrap();
            client.write_all(&request).await.unwrap();
            if let Some(status) = expected_status {
                let mut reply = [0; 10];
                client.read_exact(&mut reply).await.unwrap();
                assert_eq!(reply[0], 0x05, "{reason}");
                assert_eq!(reply[1], status, "{reason}");
            }
            assert!(task.await.unwrap(), "{reason}");
        }
    }
    #[tokio::test]
    async fn reports_a_busy_port_instead_of_pretending_to_run() {
        let taken = bind(ListenConfig::loopback(0)).await.unwrap();
        let port = taken.local_addr().unwrap().port();
        let error = bind(ListenConfig::loopback(port)).await.unwrap_err();
        assert!(
            error.contains(&port.to_string()),
            "the error must name the port that is busy, got {error:?}"
        );
    }
    #[tokio::test]
    async fn mtproto_init_beginning_with_the_socks5_version_is_not_misrouted() {
        // One init in 256 starts with 0x05. Routing it to the SOCKS5 handler is
        // what makes Telegram work only every other attempt.
        let stats = Stats::new();
        let init = ambiguous_client_init(&stats.secret, 2);
        let (port, server) = start_proxy(stats.clone(), true).await;
        let mut client = TcpStream::connect(("127.0.0.1", port)).await.unwrap();
        client.write_all(&init).await.unwrap();
        // Detection must land on MTProto, which records the data centre. The
        // SOCKS5 path would instead answer with a handshake reply.
        wait_until("the MTProto data centre to be recorded", || {
            stats.last_dc.load(Ordering::Relaxed) == 2
        })
        .await;
        stats.stop();
        let _ = server.await.unwrap();
    }
    #[tokio::test]
    async fn fragmented_socks5_greeting_is_still_detected() {
        let stats = Stats::new();
        let (port, server) = start_proxy(stats.clone(), true).await;
        let mut client = TcpStream::connect(("127.0.0.1", port)).await.unwrap();
        // Byte-at-a-time, the way a small greeting can actually arrive.
        for byte in [0x05, 0x01, 0x00] {
            client.write_all(&[byte]).await.unwrap();
            tokio::time::sleep(Duration::from_millis(1)).await;
        }
        let mut greeting = [0; 2];
        tokio::time::timeout(Duration::from_secs(5), client.read_exact(&mut greeting))
            .await
            .expect("the proxy must answer the greeting")
            .unwrap();
        assert_eq!(greeting, [0x05, 0x00]);
        stats.stop();
        let _ = server.await.unwrap();
    }
    #[tokio::test]
    async fn network_listener_refuses_non_telegram_destinations() {
        let stats = Stats::new();
        let (port, server) = start_proxy(stats.clone(), false).await;
        let (_client, reply) =
            socks5_exchange(port, &socks5_ipv4_request(0x01, [1, 1, 1, 1], 443)).await;
        assert_eq!(
            reply[1], 0x02,
            "a shared listener must not relay arbitrary destinations"
        );
        stats.stop();
        let _ = server.await.unwrap();
    }
    #[tokio::test]
    async fn loopback_listener_relays_direct_destinations() {
        let echo = TcpListener::bind("127.0.0.1:0").await.unwrap();
        let echo_port = echo.local_addr().unwrap().port();
        tokio::spawn(async move {
            let (mut stream, _) = echo.accept().await.unwrap();
            let mut buffer = [0; 5];
            stream.read_exact(&mut buffer).await.unwrap();
            stream.write_all(&buffer).await.unwrap();
        });
        let stats = Stats::new();
        let (port, server) = start_proxy(stats.clone(), true).await;
        let (mut client, reply) =
            socks5_exchange(port, &socks5_ipv4_request(0x01, [127, 0, 0, 1], echo_port)).await;
        assert_eq!(reply[1], 0x00);
        client.write_all(b"hello").await.unwrap();
        let mut echoed = [0; 5];
        client.read_exact(&mut echoed).await.unwrap();
        assert_eq!(&echoed, b"hello");
        stats.stop();
        let _ = server.await.unwrap();
    }
    #[tokio::test]
    async fn tunnels_mtproto_through_a_websocket_relay() {
        let relay_listener = TcpListener::bind("127.0.0.1:0").await.unwrap();
        let relay_port = relay_listener.local_addr().unwrap().port();
        let response = b"a reply that only Telegram could have sent".to_vec();
        let relay = tokio::spawn(mock_relay(relay_listener, response.clone()));
        let stats = Stats::new();
        stats.transport.force_local_route(relay_port);
        let (port, server) = start_proxy(stats.clone(), false).await;
        let init = unambiguous_client_init(&stats.secret, -4);
        let mut peer = crate::mtproto::test_client_peer(&init, &stats.secret);
        let mut client = TcpStream::connect(("127.0.0.1", port)).await.unwrap();
        client.write_all(&init).await.unwrap();
        let request = b"a request that must reach Telegram unchanged".to_vec();
        let mut wire = request.clone();
        peer.encrypt(&mut wire);
        client.write_all(&wire).await.unwrap();
        let mut received = vec![0; response.len()];
        tokio::time::timeout(Duration::from_secs(10), client.read_exact(&mut received))
            .await
            .expect("the relay's answer must come back through the tunnel")
            .unwrap();
        peer.decrypt(&mut received);
        assert_eq!(
            received, response,
            "the client must see Telegram's plaintext"
        );
        let (_, init_frame, relayed) = relay.await.unwrap().unwrap();
        assert_eq!(init_frame.len(), INIT_LEN);
        assert_ne!(
            init_frame.as_slice(),
            init.as_slice(),
            "the upstream init must be freshly generated, not the client's own"
        );
        assert_eq!(
            relayed, request,
            "Telegram must receive exactly the client's plaintext"
        );
        assert_eq!(stats.last_dc.load(Ordering::Relaxed), 4);
        assert_eq!(
            stats.last_route.load(Ordering::Relaxed),
            crate::transport::RouteKind::TelegramIp.ui_code()
        );
        assert_eq!(stats.ws_failures.load(Ordering::Relaxed), 0);
        stats.stop();
        let _ = server.await.unwrap();
    }
    #[tokio::test]
    async fn connects_through_the_documented_worker_contract() {
        // Locks the contract in docs/CLOUDFLARE_WORKER.md: a server that
        // implements exactly what is documented there must carry a working
        // tunnel, and must be asked for exactly the documented URI.
        let dc = 2;
        let path = crate::transport::worker_path(dc).unwrap();
        let listener = TcpListener::bind("127.0.0.1:0").await.unwrap();
        let worker_port = listener.local_addr().unwrap().port();
        let response = b"an answer relayed by the worker".to_vec();
        let worker = tokio::spawn(mock_relay(listener, response.clone()));
        let stats = Stats::new();
        stats.transport.force_local_route_with(
            worker_port,
            crate::transport::RouteKind::CloudflareWorker,
            path.clone(),
        );
        let (port, server) = start_proxy(stats.clone(), false).await;
        let init = unambiguous_client_init(&stats.secret, dc as i16);
        let mut peer = crate::mtproto::test_client_peer(&init, &stats.secret);
        let mut client = TcpStream::connect(("127.0.0.1", port)).await.unwrap();
        client.write_all(&init).await.unwrap();
        let request = b"a request relayed to the worker".to_vec();
        let mut wire = request.clone();
        peer.encrypt(&mut wire);
        client.write_all(&wire).await.unwrap();
        let mut received = vec![0; response.len()];
        tokio::time::timeout(Duration::from_secs(10), client.read_exact(&mut received))
            .await
            .expect("the worker's answer must come back through the tunnel")
            .unwrap();
        peer.decrypt(&mut received);
        assert_eq!(received, response);
        let (requested, _, relayed) = worker.await.unwrap().unwrap();
        assert_eq!(
            requested, path,
            "a deployed worker must serve exactly the documented path and query"
        );
        assert_eq!(relayed, request);
        assert_eq!(
            stats.last_route.load(Ordering::Relaxed),
            crate::transport::RouteKind::CloudflareWorker.ui_code()
        );
        stats.stop();
        let _ = server.await.unwrap();
    }
    #[tokio::test]
    async fn a_tunnel_counts_only_after_the_handshake_succeeds() {
        // Accepts TCP and then stays silent, so the WebSocket handshake never
        // completes: the proxy is mid-attempt and no tunnel exists.
        let silent = TcpListener::bind("127.0.0.1:0").await.unwrap();
        let relay_port = silent.local_addr().unwrap().port();
        let held = tokio::spawn(async move {
            let accepted = silent.accept().await;
            tokio::time::sleep(Duration::from_secs(30)).await;
            drop(accepted);
        });
        let stats = Stats::new();
        stats.transport.force_local_route(relay_port);
        let (port, server) = start_proxy(stats.clone(), false).await;
        let init = unambiguous_client_init(&stats.secret, 2);
        let mut client = TcpStream::connect(("127.0.0.1", port)).await.unwrap();
        client.write_all(&init).await.unwrap();
        wait_until("the init to be parsed", || {
            stats.last_dc.load(Ordering::Relaxed) == 2
        })
        .await;
        tokio::time::sleep(Duration::from_millis(300)).await;
        assert_eq!(
            stats.ws.load(Ordering::Relaxed),
            0,
            "a handshake still in flight must not be reported as a working tunnel"
        );
        assert_eq!(
            stats.last_route.load(Ordering::Relaxed),
            0,
            "no route may be announced before a tunnel is established"
        );
        stats.stop();
        held.abort();
        let _ = server.await.unwrap();
    }
    #[tokio::test]
    async fn counts_a_failure_when_no_route_answers() {
        let dead = TcpListener::bind("127.0.0.1:0").await.unwrap();
        let dead_port = dead.local_addr().unwrap().port();
        drop(dead);
        let stats = Stats::new();
        stats.transport.force_local_route(dead_port);
        let (port, server) = start_proxy(stats.clone(), false).await;
        let init = unambiguous_client_init(&stats.secret, 2);
        let mut client = TcpStream::connect(("127.0.0.1", port)).await.unwrap();
        client.write_all(&init).await.unwrap();
        wait_until("the failed tunnel to be counted", || {
            stats.ws_failures.load(Ordering::Relaxed) > 0
        })
        .await;
        assert_eq!(
            stats.last_route.load(Ordering::Relaxed),
            0,
            "a route must not be reported as working when every attempt failed"
        );
        assert_eq!(stats.ws.load(Ordering::Relaxed), 0);
        stats.stop();
        let _ = server.await.unwrap();
    }
    #[tokio::test]
    #[ignore = "requires live Telegram network access"]
    async fn accepts_mtproto_and_builds_live_media_tunnel() {
@@ -479,7 +1060,8 @@ mod tests {
        let stats = Stats::new();
        let server_stats = stats.clone();
-        let server = tokio::spawn(async move { run(server_stats, false, port).await });
+        let server =
            tokio::spawn(async move { run(server_stats, ListenConfig::loopback(port)).await });
        while !stats.running.load(Ordering::SeqCst) {
            tokio::task::yield_now().await;
        }
@@ -9,6 +9,7 @@ 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>>;
@@ -29,6 +30,34 @@ impl RouteKind {
            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)]
@@ -37,6 +66,24 @@ pub struct Route {
    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)]
@@ -66,6 +113,28 @@ struct HealthState {
 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 {
@@ -159,17 +228,26 @@ impl TransportEngine {
    }
    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(destination) = telegram_ips(key.dc).first() else {
+        let Some(path) = worker_path(key.dc) else {
            return routes;
        };
        for domain in self.worker_domains.lock().unwrap().iter() {
-            routes.push(Route {
+            let path = path.clone();
-                connect_host: domain.clone(),
+            routes.push(Route::https(
-                websocket_host: domain.clone(),
+                domain.clone(),
-                path: format!("/apiws?dst={}&dc={}", destination, key.dc),
+                domain.clone(),
-                kind: RouteKind::CloudflareWorker,
+                path,
-            });
+                RouteKind::CloudflareWorker,
            ));
        }
        routes
    }
@@ -200,6 +278,28 @@ impl TransportEngine {
    }
 }
 /// 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
@@ -234,23 +334,23 @@ pub fn routes_for_dc(dc: u16, media: bool) -> Vec<Route> {
    for websocket_host in &websocket_hosts {
        for (index, ip) in ips.iter().enumerate() {
-            routes.push(Route {
+            routes.push(Route::https(
-                connect_host: (*ip).to_owned(),
+                (*ip).to_owned(),
-                websocket_host: websocket_host.clone(),
+                websocket_host.clone(),
-                path: "/apiws".to_owned(),
+                "/apiws".to_owned(),
-                kind: if index == 0 {
+                if index == 0 {
                    RouteKind::TelegramIp
                } else {
                    RouteKind::AlternateTelegramIp
                },
-            });
+            ));
        }
-        routes.push(Route {
+        routes.push(Route::https(
-            connect_host: websocket_host.clone(),
+            websocket_host.clone(),
-            websocket_host: websocket_host.clone(),
+            websocket_host.clone(),
-            path: "/apiws".to_owned(),
+            "/apiws".to_owned(),
-            kind: RouteKind::SystemDns,
+            RouteKind::SystemDns,
-        });
+        ));
    }
    routes
 }
@@ -258,7 +358,7 @@ pub fn routes_for_dc(dc: u16, media: bool) -> Vec<Route> {
 async fn connect_route(route: &Route) -> Result<TelegramWebSocket, String> {
    let tcp = tokio::time::timeout(
        CONNECT_TIMEOUT,
-        TcpStream::connect((route.connect_host.as_str(), 443)),
+        TcpStream::connect((route.connect_host.as_str(), route.port)),
    )
    .await
    .map_err(|_| "TCP connect timeout".to_owned())?
@@ -266,7 +366,8 @@ async fn connect_route(route: &Route) -> Result<TelegramWebSocket, String> {
    tcp.set_nodelay(true)
        .map_err(|error| format!("TCP_NODELAY: {}", error))?;
-    let url = format!("wss://{}{}", route.websocket_host, route.path);
+    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()
@@ -278,6 +379,19 @@ async fn connect_route(route: &Route) -> Result<TelegramWebSocket, String> {
            .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.
@@ -373,6 +487,235 @@ mod tests {
        );
    }
    #[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() {
@@ -1,8 +1,9 @@
 {
  "$schema": "https://schema.tauri.app/config/2",
  "productName": "TGLock",
-  "version": "2.0.0-beta.1",
+  "version": "2.0.0-beta.5",
  "identifier": "com.bysonic.tglock",
  "mainBinaryName": "tglock",
  "build": {
    "beforeDevCommand": "npm run dev",
    "devUrl": "http://localhost:1420",
@@ -35,7 +35,7 @@ let status: Status = {
  activeConnections: 0,
  tunnels: 0,
  dataCenter: null,
-  route: "Автоматический маршрут",
+  route: "Маршрут ещё не выбран",
  failures: 0,
  uptimeSeconds: 0,
  port: 1080,
@@ -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" },
    });
  },
 };