chore(release): 2.0.0-beta.10 (#46)

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

.github/workflows/ci.yml

@@ -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,120 @@ 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)"
+
+      # Настройки из файла и приоритет флага над файлом.
+      - name: Read settings from a file
+        run: |
+          cat > tglock.toml <<'CONF'
+          port = 18090
+          secret = "dd00112233445566778899aabbccddeeff"
+          worker = ["example.workers.dev"]
+          CONF
+          timeout --preserve-status --signal=TERM 5 \
+            ./target/release/tglock-cli --config tglock.toml > conf.log 2>&1
+          cat conf.log
+          grep -q '127.0.0.1:18090' conf.log
+          grep -q 'secret=dd00112233445566778899aabbccddeeff' conf.log
+          grep -q 'example.workers.dev' conf.log
+          # Флаг должен перекрывать файл.
+          timeout --preserve-status --signal=TERM 5 \
+            ./target/release/tglock-cli --config tglock.toml --port 18091 > over.log 2>&1
+          grep -q '127.0.0.1:18091' over.log
+          # Опечатка в файле обязана быть ошибкой, а не молчаливым дефолтом.
+          echo 'porrt = 1443' > bad.toml
+          if ./target/release/tglock-cli --config bad.toml; then
+            echo "опечатка в конфиге прошла незамеченной"; exit 1
+          fi
+
+      # Закрытый stdout не должен ронять демон: println! при ошибке записи
+      # паникует, а канал закрывается штатно — `| head`, закрытый терминал,
+      # перезапуск сборщика логов.
+      - name: Survive a closed stdout
+        run: |
+          set +e
+          timeout --signal=TERM 5 ./target/release/tglock-cli --port 18092 2> pipe-err.log | head -2
+          set -e
+          cat pipe-err.log
+          if grep -qi 'panic' pipe-err.log; then
+            echo "демон упал из-за закрытого stdout"; exit 1
+          fi
+
   msrv:
     name: Rust 1.88 compatibility
     runs-on: macos-latest
@@ -59,6 +193,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

.github/workflows/release.yml

@@ -1,6 +1,7 @@
 name: Release
 
 on:
+  workflow_dispatch:
   push:
     tags: ["v*"]
 
@@ -8,7 +9,40 @@ permissions:
   contents: write
 
 jobs:
+  # Токен Actions умеет создавать релиз только на HEAD ветки по умолчанию. Если
+  # тег отстал хоть на один коммит, GitHub отвечает «Resource not accessible by
+  # integration» — сообщение про права, хотя права в порядке и дело в положении
+  # тега. Так утонул v2.0.0-beta.8: тег поставили, следом дописали коммит в main,
+  # и три сборки по восемь минут закончились загадочным 403.
+  #
+  # Проверка занимает секунды и идёт до сборок. Но она НЕ закрывает гонку: если
+  # запушить в main уже после её прохождения, публикация всё равно упадёт — как и
+  # случилось с beta.8. Единственная настоящая защита — порядок действий: тег
+  # ставится последним, и пока идёт релиз, в main не пушим.
+  guard:
+    name: Тег должен стоять на HEAD
+    runs-on: ubuntu-latest
+    steps:
+      - name: Сверить тег с веткой по умолчанию
+        env:
+          GH_TOKEN: ${{ github.token }}
+        run: |
+          branch=$(gh api "repos/$GITHUB_REPOSITORY" -q .default_branch)
+          head=$(gh api "repos/$GITHUB_REPOSITORY/commits/$branch" -q .sha)
+          if [ "$head" = "$GITHUB_SHA" ]; then
+            echo "$GITHUB_REF_NAME и $branch указывают на $head — собираем."
+            exit 0
+          fi
+          echo "::error::$GITHUB_REF_NAME стоит на $GITHUB_SHA, а $branch — на $head. Публикация упадёт с 403, потому что токен Actions создаёт релиз только на HEAD ветки по умолчанию."
+          echo "Переставьте тег и запушьте заново:"
+          echo "  git tag -d $GITHUB_REF_NAME"
+          echo "  git push origin :refs/tags/$GITHUB_REF_NAME"
+          echo "  git tag -a $GITHUB_REF_NAME $head -m 'TGLock ...'"
+          echo "  git push origin $GITHUB_REF_NAME"
+          exit 1
+
   publish:
+    needs: guard
     name: Build ${{ matrix.platform }}
     strategy:
       fail-fast: false
@@ -16,15 +50,15 @@ jobs:
         include:
           - platform: macOS universal
             os: macos-14
-            args: --target universal-apple-darwin
+            args: --bundles app,dmg --target universal-apple-darwin
             rust-targets: aarch64-apple-darwin,x86_64-apple-darwin
           - platform: Windows x64
             os: windows-latest
-            args: --target x86_64-pc-windows-msvc
+            args: --bundles nsis --target x86_64-pc-windows-msvc
             rust-targets: x86_64-pc-windows-msvc
           - platform: Linux x64
             os: ubuntu-22.04
-            args: --target x86_64-unknown-linux-gnu
+            args: --bundles appimage,deb --target x86_64-unknown-linux-gnu
             rust-targets: x86_64-unknown-linux-gnu
 
     runs-on: ${{ matrix.os }}
@@ -63,12 +97,117 @@ jobs:
         with:
           tagName: v__VERSION__
           releaseName: TGLock v__VERSION__
+          # Только инструкция по скачиванию: она одна и та же для любой версии.
+          # Список изменений дописывается в release notes при выпуске — иначе
+          # выходит как в бетах 1-7, где каждая несла один и тот же текст «новый
+          # TGLock, полностью обновлённый интерфейс» и понять, что поменялось,
+          # было невозможно.
           releaseBody: |
-            Новый TGLock: адаптивный MTProto/WebSocket-транспорт и полностью обновлённый интерфейс на Tauri 2.
+            ## Что скачивать
 
-            - macOS: скачайте универсальный `.dmg` или `.app.tar.gz`
-            - Windows: скачайте `.exe` установщик
-            - Linux: скачайте `.AppImage` или `.deb`
+            - **Windows** — `.exe`, установщик
+            - **macOS** — универсальный `.dmg` (или `.app.tar.gz`)
+            - **Linux** — `.AppImage` или `.deb`
+            - **Сервер, контейнер, машина без монитора** — `tglock-cli-*`: то же самое, но без графического интерфейса
+
+            Если Windows ругается на файл — [почему так и что с этим делать](https://github.com/by-sonic/tglock#-антивирус-ругается-smartscreen-предупреждает-virustotal-показывает-детекты).
           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 }}

Cargo.lock

@@ -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.10"
 dependencies = [
  "aes",
  "cipher",
+ "clap",
  "ctr",
  "futures-util",
  "native-tls",
@@ -3451,6 +3570,7 @@ dependencies = [
  "tauri-build",
  "tokio",
  "tokio-tungstenite",
+ "toml 0.8.2",
 ]
 
 [[package]]
@@ -3558,6 +3678,7 @@ dependencies = [
  "libc",
  "mio",
  "pin-project-lite",
+ "signal-hook-registry",
  "socket2",
  "tokio-macros",
  "windows-sys 0.61.2",
@@ -3944,6 +4065,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 +4298,9 @@ dependencies = [
  "webview2-com-macros",
  "webview2-com-sys",
  "windows",
- "windows-core 0.61.2",
- "windows-implement 0.60.2",
- "windows-interface 0.59.3",
+ "windows-core",
+ "windows-implement",
+ "windows-interface",
 ]
 
 [[package]]
@@ -4195,7 +4322,7 @@ checksum = "381336cfffd772377d291702245447a5251a2ffa5bad679c99e61bc48bacbf9c"
 dependencies = [
  "thiserror 2.0.19",
  "windows",
- "windows-core 0.61.2",
+ "windows-core",
 ]
 
 [[package]]
@@ -4251,7 +4378,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 +4390,7 @@ version = "0.2.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "3beeceb5e5cfd9eb1d76b381630e82c4241ccd0d27f1a39ed41b2760b255c5e8"
 dependencies = [
- "windows-core 0.61.2",
-]
-
-[[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",
+ "windows-core",
 ]
 
 [[package]]
@@ -4285,11 +4399,11 @@ version = "0.61.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "c0fdd3ddb90610c7638aa2b3a3ab2904fb9e5cdbecc643ddb3647212781c4ae3"
 dependencies = [
- "windows-implement 0.60.2",
- "windows-interface 0.59.3",
+ "windows-implement",
+ "windows-interface",
  "windows-link 0.1.3",
- "windows-result 0.3.4",
- "windows-strings 0.4.2",
+ "windows-result",
+ "windows-strings",
 ]
 
 [[package]]
@@ -4298,22 +4412,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 +4428,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 +4457,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 +4470,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 +4730,7 @@ dependencies = [
  "webkit2gtk-sys",
  "webview2-com",
  "windows",
- "windows-core 0.61.2",
+ "windows-core",
  "windows-version",
  "x11-dl",
 ]

Cargo.toml

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

HABR.md

@@ -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).

README.md

@@ -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-альтернатив)
-- 💻 Хочется решение для **Windows, macOS или Linux** без подписок и серверов
+- 🍎 Нужен графический интерфейс под **macOS**
+- 💻 Нужно решение для **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 | |
-| **macOS** (Apple Silicon + Intel) | universal `.dmg` | |
-| **Linux** (x86_64) | `.AppImage` / `.deb` | |
+| Платформа | Файл |
+|---|---|
+| **Windows 10/11** (x64) | `_x64-setup.exe` |
+| **macOS** (Apple Silicon + Intel) | universal `.dmg` |
+| **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,126 @@ Telegram → Настройки → **Продвинутые** → Тип сое
 
 ### 🏠 LAN-режим — один прокси на всю квартиру
 
-В окне TGLock включи галочку **LAN** — приложение начнёт слушать на `0.0.0.0`. Все устройства в твоей домашней сети (телефон, планшет, ноутбук, телевизор) смогут подключиться к `<твой-IP>:1080` и тоже получить рабочий Telegram. IP отобразится прямо в интерфейсе TGLock — копируй и вписывай в настройки Telegram на остальных устройствах.
+В окне TGLock включи галочку **LAN** — приложение начнёт слушать на `0.0.0.0`. Все устройства в домашней сети (телефон, планшет, ноутбук, телевизор) смогут подключиться к `<IP-компьютера>:1080` и тоже получить рабочий Telegram.
 
-Удобно, если дома один комп всегда включён — он становится «домашним Telegram-роутером».
+Когда LAN-режим включён, TGLock показывает в окне **готовый адрес** вида `192.168.1.7:1080` — нажми на него, чтобы скопировать. Плюс он сам открывает ссылку `tg://proxy`, где уже подставлены адрес, порт и секрет: её достаточно переслать себе в Telegram и открыть на телефоне.
+
+> ⚠️ На другом устройстве **не вводи `127.0.0.1`** — для него это оно само, а не твой компьютер. Нужен именно тот адрес, который показан в окне TGLock. Это же касается телефона в эмуляторе (MuMuPlayer, BlueStacks и подобных): внутри эмулятора Android — отдельная машина со своей сетью.
+
+Если адрес нужен руками: `ipconfig` на Windows, `ip a` на Linux, `ifconfig` на macOS.
+
+Удобно, если дома один компьютер всегда включён — он становится «домашним Telegram-роутером».
+
+В LAN-режиме TGLock пропускает **только адреса Telegram**. Открытым SOCKS5-прокси для всего интернета он при этом не становится — иначе им бы воспользовались не только твои устройства.
+
+> **📵 С телефона не подключается?** Открой **Диагностика** на компьютере и посмотри две цифры.
+>
+> - **Соединения `0` и Отклонено `0`** — телефон до компьютера не дошёл. Дело не в TGLock: проверь, что оба устройства в одной сети (телефон может сидеть на гостевом Wi-Fi или в мобильном интернете), что в роутере не включена изоляция клиентов, и что брандмауэр пускает входящие на порт TGLock.
+> - **Соединения растут, Отклонено растёт** — телефон дошёл, но просит адрес, который LAN-режим не пропускает. Конкретный адрес назван в журнале событий ниже — пришли эту строку в issue.
+> - **Не опознаны растёт** — телефон дошёл, но договориться не вышло. Почти всегда в Telegram на телефоне вписана ссылка от прошлого запуска, то есть другой секрет. Сверь её с той, что показана в окне сейчас.
+> - **Соединения растут, Туннели `0`** — до Telegram не доходит уже сам компьютер. Это [Cloudflare Worker](docs/CLOUDFLARE_WORKER.md), а не проблема LAN.
+
+### 🖥 Без графического интерфейса: `tglock-cli`
+
+Для сервера, виртуалки, контейнера и машины без монитора или без 3D-ускорения. Это отдельный бинарь, в котором **нет ни Tauri, ни системного WebView** — там, где окно просто не создаётся, CLI работает.
+
+```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                          # все флаги
+```
+
+#### Файл настроек
+
+Чтобы не собирать батник с ключами при каждом запуске ([#32](https://github.com/by-sonic/tglock/issues/32)), положите рядом с бинарём `tglock.toml` — он подхватится сам. Или укажите путь: `tglock-cli --config /etc/tglock.toml`.
+
+```toml
+port = 1080
+lan = true
+
+# Секрет — вторая половина ссылки tg://proxy. Для сервиса его нужно закрепить,
+# иначе после перезапуска все настроенные клиенты отвалятся. Запустите один
+# раз, скопируйте из напечатанной ссылки и вставьте сюда.
+secret = "dd00112233445566778899aabbccddeeff"
+
+worker = ["my-name.workers.dev"]
+```
+
+Полный пример со всеми полями и пояснениями — [`tglock.example.toml`](tglock.example.toml).
+
+Приоритеты: значения по умолчанию → файл → флаги. Флаг всегда сильнее файла. Флаги-переключатели (`--lan`, `--allow-direct`, `--quiet`) могут только включать: их отсутствие означает «взять из файла», а не «выключить».
+
+Опечатка в файле — ошибка при старте с перечислением допустимых полей, а не молча проигнорированная строка. Сервис, который из-за `porrt = 1443` слушает 1080, хуже сервиса, который не запустился.
+
+Файл с секретом внутри держите с правами `600`: это доступ к вашему прокси.
+
+При запуске печатается готовая `tg://proxy`-ссылка — её можно открыть на любом устройстве в сети, чтобы Telegram настроился сам. Дальше в лог идёт по строке на каждое изменение состояния: сколько соединений, какой дата-центр, какой маршрут живой, сколько сбоев, сколько запросов отклонено политикой «только Telegram» и сколько клиентов не опознано. Отдельными строками отмечаются подключившиеся устройства, адреса, из-за которых был отказ, и клиенты, с которыми не удалось договориться, — по ним видно, дошёл ли телефон до сервиса вообще и не вписан ли в нём устаревший секрет.
+
+Прав администратора не нужно: TGLock не правит ни системный DNS, ни файл `hosts` — нужные адреса Telegram зашиты в маршрутах, а TLS SNI остаётся настоящим.
+
+`--lan` и любой другой сетевой адрес пропускают **только** адреса Telegram. Обычным SOCKS5-прокси TGLock становится исключительно по явному `--allow-direct`, и на сетевом адресе это открытый прокси для всего интернета — включайте осознанно.
+
+#### Юнит для systemd
+
+```ini
+[Unit]
+Description=TGLock — Telegram через WebSocket-туннель
+After=network-online.target
+Wants=network-online.target
+
+[Service]
+Type=exec
+ExecStart=/usr/local/bin/tglock-cli --config /etc/tglock.toml
+Restart=on-failure
+RestartSec=5s
+StateDirectory=tglock
+DynamicUser=yes
+NoNewPrivileges=yes
+ProtectSystem=strict
+ProtectHome=yes
+PrivateTmp=yes
+RestrictAddressFamilies=AF_INET AF_INET6
+
+[Install]
+WantedBy=multi-user.target
+```
+
+```bash
+sudo install -m755 tglock-cli-x86_64-unknown-linux-gnu /usr/local/bin/tglock-cli
+sudo install -m600 tglock.example.toml /etc/tglock.toml   # и отредактировать
+sudo systemctl enable --now tglock
+journalctl -u tglock -f
+```
+
+**Закреплённый секрет здесь обязателен**, и это не украшение: секрет — половина `tg://proxy`-ссылки. Без него он генерируется заново при каждом старте, и после первого же `systemctl restart` все настроенные клиенты перестанут подключаться. Задайте `secret` в `/etc/tglock.toml` (файл с правами `600`) либо `secret_file = "/var/lib/tglock/secret"` — тогда `StateDirectory=tglock` создаст каталог с нужными правами, а файл запишется с режимом `600`.
+
+При старте без закреплённого секрета CLI печатает предупреждение — молча уйти в такое состояние он не даст.
+
+Остановка по `systemctl stop` приходит как `SIGTERM` — CLI закрывает туннели и выходит с нулевым кодом, а не умирает по `SIGKILL`.
+
+#### Docker
+
+```dockerfile
+FROM rust:1.88 AS build
+WORKDIR /src
+COPY . .
+RUN cargo build --release --locked --no-default-features --features cli --bin tglock-cli
+
+FROM debian:bookworm-slim
+RUN apt-get update && apt-get install -y --no-install-recommends ca-certificates \
+    && rm -rf /var/lib/apt/lists/*
+COPY --from=build /src/target/release/tglock-cli /usr/local/bin/tglock-cli
+EXPOSE 1080
+ENTRYPOINT ["tglock-cli", "--lan", "--secret-file", "/data/secret"]
+```
+
+```bash
+docker run -d --name tglock -p 1080:1080 -v tglock-data:/data tglock
+```
+
+Образу не нужны ни Node.js, ни `libwebkit2gtk` — только `ca-certificates` для проверки сертификата Telegram.
 
 ---
 
@@ -115,7 +281,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 +289,21 @@ Telegram Desktop / mobile (через LAN)
                  достаёт номер DC
               ▼
    WSS → kws{dc}.web.telegram.org
+         каскад маршрутов, см. ниже
               ▼
         Telegram Data Center
 ```
 
-1. **Локальный SOCKS5-прокси** перехватывает соединения Telegram Desktop.
-2. Из первых 64 байт `obfuscated2`-пакета **расшифровывается номер DC** — AES-256-CTR, ключ в байтах `[8..40]`, IV в `[40..56]`, DC ID — `i32` в `[60..64]`.
-3. Трафик заворачивается в **WebSocket** к `kws{dc}.web.telegram.org` — это **тот же домен**, через который работает Telegram Web в браузере.
-4. Провайдер видит **TLS-handshake к `web.telegram.org`** — это легитимный HTTPS. DPI не видит MTProto. IP-шейпинг не работает, потому что `web.telegram.org` не блокируется в принципе.
-5. Весь остальной трафик (не-Telegram) проходит **напрямую** — без замедления.
+1. **Локальный прокси** принимает соединения Telegram: и MTProto (по ссылке `tg://proxy`), и SOCKS5.
+2. Из первых 64 байт `obfuscated2`-пакета **расшифровывается номер DC** — AES-256-CTR, ключ в байтах `[8..40]`, IV в `[40..56]`, индекс DC — `i16` в `[60..62]`. Отрицательное значение означает медиа-соединение.
+3. Трафик заворачивается в **WebSocket** к `kws{dc}.web.telegram.org` — это тот же домен, через который работает Telegram Web в браузере.
+4. **Маршрут выбирается каскадом**, и это главное отличие 2.0 от первой версии. Один домен может резолвиться в недоступный адрес, поэтому по очереди пробуются: закреплённые IP Telegram, их дублёры `kwsN-1`, системный DNS и — если ты его настроил — твой собственный Cloudflare Worker. Упавший маршрут уходит в cooldown с удвоением задержки, удачный запоминается для этого DC. Системный DNS и файл `hosts` при этом **не изменяются**: TCP-соединение идёт на закреплённый IP, а TLS SNI и заголовок `Host` остаются настоящими, поэтому сертификат Telegram проверяется как обычно.
+5. Провайдер видит **TLS-handshake к `web.telegram.org`** — легитимный HTTPS, MTProto в нём не виден.
+6. Весь остальной трафик (не-Telegram) проходит **напрямую** — без замедления.
 
-📖 **Подробный технический разбор архитектуры** — см. [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 +317,13 @@ Telegram Desktop / mobile (через LAN)
 | Нужен сервер / подписка | ❌ | ❌ | ✅ ($) | **❌** |
 | Только Telegram | ❌ | ❌ | ❌ | **✅** |
 | LAN-шаринг | ❌ | сложно | ✅ | **✅ (галочка)** |
-| Размер | ~200 КБ | ~5 МБ | ~80 МБ | **компактное desktop-приложение** |
-| Цена | 0 ₽ | 0 ₽ | $3–10/мес | **0 ₽** |
+| Режим без GUI | ✅ | ✅ | ❌ | **✅ (`tglock-cli`)** |
+| Размер | ~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 +332,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 +350,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 +373,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
-chmod +x ~/Downloads/tglock-macos-arm64
+xattr -cr /Applications/TGLock.app
 ```
 
 После этого приложение запустится двойным кликом из Finder.
@@ -214,6 +393,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 +412,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 +446,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 +466,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">
-  <a href="https://t.me/rosevpnru_bot">
-    <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"/>
-  </a>
-</p>
+- **Нашёл баг** — [открой issue](https://github.com/by-sonic/tglock/issues/new). Полезнее всего: ОС и версия, что показывает вкладка диагностики (маршрут, DC, число сбоев) и провайдер. Для `tglock-cli` — вывод из консоли.
+- **Хочешь фичу** — тоже issue. Если её нет в планах, так и будет написано, без месяцев тишины.
+- **Присылаешь PR** — перед отправкой прогони проверки выше, они те же, что в CI. Небольшие PR ревьюятся быстрее.
+- **Не работает после релиза** — это регрессия, пиши сразу, такие вещи в приоритете.
 
-**Что внутри RoseVPN:**
-
-- 🔥 **Hysteria2 + VLESS-Reality fallback** — обходит TSPU и агрессивный DPI
-- 🛡 **Без логов трафика** — приватность по умолчанию
-- 🎁 **Бесплатный пробный период** — без карты, без регистрации
-- 📱 **Karing-клиент** с автонастройкой — установка в 2 тапа
-- 💻 **Windows, macOS, iOS, Android** — везде нативные приложения
-- 🔄 **SNI-ротация** на случай новых блокировок
-
-Подключение — через Telegram-бот **[@rosevpnru_bot](https://t.me/rosevpnru_bot)**.
+Известные ограничения, о которых не нужно открывать issue: звонки (UDP), сервисы кроме Telegram (только MTProto), Android и iOS (обсуждается в [#9](https://github.com/by-sonic/tglock/issues/9)).
 
 ---
 
@@ -300,5 +516,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>

build.rs

@@ -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();
 }

docs/ARCHITECTURE_V2.md

@@ -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,105 @@ 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.
+
+### Что считается адресом Telegram
+
+Список сетей — опубликованный самим Telegram
+(<https://core.telegram.org/resources/cidr.txt>), он лежит в `telegram_net` и
+проверяется по маске префикса. До 2.0.0-beta.9 сравнивались два первых октета,
+то есть «телеграмом» считались целиком `149.154.0.0/16`, `91.108.0.0/16`,
+`91.105.0.0/16` и `185.76.0.0/16`, а IPv6 не распознавался вовсе. Ошибка была в
+обе стороны:
+
+- чужие адреса внутри этих `/16` уходили в MTProto-туннель и умирали там;
+- настоящие адреса дата-центров по IPv6 отклонялись как посторонние.
+
+Второе и давало «на компьютере работает, с телефона нет» (#42): на loopback
+неопознанный адрес всё равно релеился напрямую, поэтому там дефект не
+проявлялся, а на сетевом слушателе тот же адрес получал отказ.
+
+Назначение делится на три вида:
+
+| Вид | Что это | Что делаем |
+|---|---|---|
+| Дата-центр | IP из опубликованных сетей, v4 или v6 | заворачиваем в WebSocket |
+| Веб Telegram | имя из `telegram.org`, `t.me`, `telegram.me`, `telesco.pe`, `cdn-telegram.org` | пропускаем как есть — это обычный HTTPS, а не MTProto |
+| Всё остальное | — | напрямую на loopback, отказ на сетевом адресе |
+
+Имена сопоставляются по границе метки, поэтому `telegram.org.example.com` —
+посторонний домен. В ограниченном режиме имя разрешается заранее, и адреса
+внутри локальной сети (`127.0.0.0/8`, `10/8`, `172.16/12`, `192.168/16`,
+`100.64/10`, `fc00::/7`, `fe80::/10`) отбрасываются: назначение выбирает чужое
+устройство, и DNS-ответ не должен превращать TGLock в дверь во внутреннюю сеть
+этой машины.
+
+### Отказ перестаёт быть молчаливым
+
+Отклонённый запрос увеличивает счётчик `blocked` и один раз называет адрес в
+журнале; повторы того же адреса склеиваются, чтобы не забить журнал одной
+строкой. Отдельно отмечается первое подключение с каждого сетевого адреса.
+
+Без этого «с телефона не работает» неразличимо распадалось на два случая:
+телефон не дошёл до машины (сеть, брандмауэр, изоляция клиентов на роутере) —
+и дошёл, но попросил адрес, который мы не пропускаем. Первый виден как ноль
+соединений и ноль отказов, второй — как соединения есть, отказы растут.
+
+Третий случай нашёлся, когда репортёр #42 прислал диагностику: у него было ноль
+отказов и работающие туннели, то есть оба счётчика говорили «всё хорошо».
+Клиент, который дошёл до прокси, но не сумел договориться, не попадал ни в
+один из них. Соединение просто закрывалось: `active` дёргался вверх и обратно.
+
+Теперь такие клиенты считает `unknown_clients`, и журнал называет адрес и
+причину. Их две:
+
+- MTProto-init не разбирается под текущим секретом. Почти всегда это ссылка
+  `tg://proxy` от прошлого запуска: секрет — её половина, и клиент со
+  сохранённой старой ссылкой попадает ровно сюда. Со стороны Telegram это и
+  есть «прокси настроен неверно и будет отключён» (#37).
+- SOCKS5-приветствие не разбирается. Сюда же попадает MTProto-соединение,
+  ушедшее в SOCKS5-ветку по неоднозначному первому байту, если полный init не
+  успел прийти за `PROTOCOL_PROBE_TIMEOUT`.
+
+Счётчик `ws_failures` от них отличается тем, что растёт после успешного
+рукопожатия с клиентом: там договорились с клиентом, но не смогли с Telegram.
+
+## Учёт состояния
+
+`Stats::ws` считает **установленные** туннели: счётчик поднимается после
+успешного `transport.connect`, а не перед попыткой. Иначе интерфейс
+рапортовал бы «Telegram на связи», пока рукопожатие ещё перебирает маршруты по
+несколько секунд каждый. Состояния «порт открыт», «идёт перебор маршрутов» и
+«туннель установлен» различимы и в GUI, и в выводе CLI.
+
+Секрет прокси — половина ссылки `tg://proxy`. Для сервиса его нужно закрепить
+файлом (`--secret-file`): под `DynamicUser` и `ProtectHome` домашней папки нет,
+путь по умолчанию не определяется, и секрет генерировался бы заново при каждом
+старте, отключая всех уже настроенных клиентов.
+
 ## Transport cascade
 
 Для каждого DC и отдельно для media-соединений строится список маршрутов:
@@ -55,6 +172,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-соединений будут добавлены после измерения,

docs/CLOUDFLARE_WORKER.md

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

docs/ISSUE_AUDIT.md

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

docs/RELEASING.md

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

package.json

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

scripts/verify_bundle_binary.py

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

src/bin/cli.rs

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

src/cli_settings.rs

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

src/config.rs

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

src/lib.rs

@@ -0,0 +1,16 @@
+//! 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 telegram_net;
+pub mod transport;
+
+/// Настройки headless-версии: файл конфигурации и сведение с флагами.
+#[cfg(feature = "cli")]
+pub mod cli_settings;

src/main.rs

@@ -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")]
@@ -46,8 +44,27 @@ struct StatusSnapshot {
     data_center: Option<u16>,
     route: String,
     failures: u32,
+    /// Падения отдельных маршрутов. Растёт даже когда соединение в итоге
+    /// состоялось через запасной адрес (by-sonic/tglock#32).
+    route_failures: u32,
+    /// Запросы, отклонённые политикой «в LAN-режиме только Telegram».
+    ///
+    /// Ноль при неработающем телефоне означает, что он вообще не дотянулся до
+    /// этой машины; не ноль — что дотянулся, и разбираться надо с адресами
+    /// (by-sonic/tglock#42).
+    blocked: u32,
+    /// Клиенты, которые дошли, но не сумели договориться. Почти всегда это
+    /// ссылка `tg://proxy` от прошлого запуска, то есть другой секрет.
+    unknown_clients: u32,
     uptime_seconds: u64,
     port: u16,
+    /// Адрес, который нужно вписать в Telegram на другом устройстве.
+    ///
+    /// В LAN-режиме это адрес этого компьютера в локальной сети. Люди искали
+    /// его в интерфейсе и не находили: вписывали `127.0.0.1`, который на
+    /// телефоне или в эмуляторе означает само устройство, и подключение не
+    /// работало (by-sonic/tglock#36).
+    share_address: Option<String>,
     logs: Vec<LogLine>,
 }
 
@@ -55,6 +72,10 @@ struct AppState {
     stats: Arc<proxy::Stats>,
     settings: Mutex<Settings>,
     active_port: Mutex<u16>,
+    /// Слушатель работающего прокси. Нужен, чтобы показать адрес для других
+    /// устройств именно тот, на котором прокси реально поднят, а не тот, что
+    /// сейчас выбран в настройках.
+    active_listen: Mutex<Option<ListenConfig>>,
     started_at: Mutex<Option<Instant>>,
     logs: Arc<Mutex<Vec<LogLine>>>,
     settings_path: PathBuf,
@@ -70,6 +91,7 @@ impl AppState {
             stats: proxy::Stats::new(),
             settings: Mutex::new(settings),
             active_port: Mutex::new(proxy::DEFAULT_PORT),
+            active_listen: Mutex::new(None),
             started_at: Mutex::new(None),
             logs: Arc::new(Mutex::new(Vec::new())),
             settings_path,
@@ -89,12 +111,13 @@ impl AppState {
     }
 
     fn snapshot(&self) -> StatusSnapshot {
+        // События прокси доходят до журнала только здесь: у ядра нет своего
+        // способа что-то показать, а интерфейс и так опрашивает состояние.
+        for event in self.stats.drain_events() {
+            self.log(event, false);
+        }
         let data_center = self.stats.last_dc.load(Ordering::Relaxed);
-        let route = match self.stats.last_route.load(Ordering::Relaxed) {
-            1 => "Telegram WebSocket",
-            2 => "Cloudflare Worker",
-            _ => "Автоматический маршрут",
-        };
+        let route = transport::route_label(self.stats.last_route.load(Ordering::Relaxed));
         StatusSnapshot {
             running: self.stats.running.load(Ordering::SeqCst),
             active_connections: self.stats.active.load(Ordering::Relaxed),
@@ -102,12 +125,16 @@ impl AppState {
             data_center: (data_center > 0).then_some(data_center),
             route: route.to_owned(),
             failures: self.stats.ws_failures.load(Ordering::Relaxed),
+            route_failures: self.stats.route_failures(),
+            blocked: self.stats.blocked.load(Ordering::Relaxed),
+            unknown_clients: self.stats.unknown_clients.load(Ordering::Relaxed),
             uptime_seconds: self
                 .started_at
                 .lock()
                 .unwrap()
                 .map_or(0, |started| started.elapsed().as_secs()),
             port: *self.active_port.lock().unwrap(),
+            share_address: share_address(*self.active_listen.lock().unwrap()),
             logs: self.logs.lock().unwrap().clone(),
         }
     }
@@ -124,6 +151,18 @@ impl AppState {
     }
 }
 
+/// Адрес, который нужно вписать в Telegram на другом устройстве.
+///
+/// Только для слушателя на `0.0.0.0`: на loopback делиться нечем, туда никто
+/// извне не достучится. Возвращается адрес этой машины в сети, а не `0.0.0.0`
+/// и не `127.0.0.1` — последний на телефоне или в эмуляторе означает само
+/// устройство, и именно на этом спотыкались (by-sonic/tglock#36).
+fn share_address(listen: Option<ListenConfig>) -> Option<String> {
+    listen
+        .filter(|listen| listen.addr.ip().is_unspecified())
+        .map(|listen| format!("{}:{}", listen.advertised_host(), listen.addr.port()))
+}
+
 fn current_time() -> String {
     let seconds = SystemTime::now()
         .duration_since(UNIX_EPOCH)
@@ -173,10 +212,16 @@ 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)
+    };
+
+    *state.active_listen.lock().unwrap() = Some(listen);
+
     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,13 +230,14 @@ 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);
         }
     });
 
     std::thread::sleep(std::time::Duration::from_millis(220));
     if !state.stats.running.load(Ordering::SeqCst) {
+        *state.active_listen.lock().unwrap() = None;
         *state.started_at.lock().unwrap() = None;
         return Err(state
             .logs
@@ -202,28 +248,8 @@ fn start_proxy(state: State<'_, AppState>) -> Result<StatusSnapshot, String> {
             .unwrap_or_else(|| "Не удалось запустить прокси".into()));
     }
 
-    state.log(
-        format!(
-            "Прокси запущен на {}:{}",
-            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(format!("Прокси запущен на {}", listen.addr), false);
+    let _ = open::that(listen.telegram_link(&state.stats.telegram_secret()));
     state.log("Открываю подключение в Telegram…", false);
     Ok(state.snapshot())
 }
@@ -231,6 +257,7 @@ fn start_proxy(state: State<'_, AppState>) -> Result<StatusSnapshot, String> {
 #[tauri::command]
 fn stop_proxy(state: State<'_, AppState>) -> StatusSnapshot {
     state.stats.stop();
+    *state.active_listen.lock().unwrap() = None;
     *state.started_at.lock().unwrap() = None;
     state.log("Защита выключена", false);
     state.snapshot()
@@ -244,13 +271,56 @@ fn push_log(logs: &Arc<Mutex<Vec<LogLine>>>, message: String, error: bool) {
     });
 }
 
-fn local_ip() -> Option<String> {
-    let socket = std::net::UdpSocket::bind("0.0.0.0:0").ok()?;
-    socket.connect("8.8.8.8:80").ok()?;
-    Some(socket.local_addr().ok()?.ip().to_string())
+/// Environment variables that make the WebView render without a GPU.
+///
+/// The window is never created when 3D acceleration is unavailable: no
+/// monitor, the default Microsoft display driver, a virtual machine without
+/// 3D enabled (by-sonic/tglock#10, by-sonic/tglock#17). For a small status
+/// panel software rendering costs nothing noticeable, so preferring it is the
+/// safer default.
+///
+/// Values already present in the environment are never overwritten, and
+/// `TGLOCK_FORCE_GPU` disables the whole mechanism.
+fn software_rendering_vars(
+    force_gpu: bool,
+    is_set: impl Fn(&str) -> bool,
+) -> Vec<(&'static str, &'static str)> {
+    if force_gpu {
+        return Vec::new();
+    }
+
+    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
@@ -258,7 +328,17 @@ fn main() {
                 .app_config_dir()
                 .map_err(|error| error.to_string())?
                 .join("settings.json");
-            app.manage(AppState::new(settings_path));
+            let state = AppState::new(settings_path);
+            // Если секрет не удалось записать, ссылка tg://proxy изменится после
+            // перезапуска и Telegram откажется подключаться к сохранённой.
+            // Раньше это происходило молча (by-sonic/tglock#37).
+            if let Some(error) = state.stats.secret_write_error() {
+                state.log(
+                    format!("Секрет не сохранён ({error}). После перезапуска ссылка изменится"),
+                    true,
+                );
+            }
+            app.manage(state);
             Ok(())
         })
         .invoke_handler(tauri::generate_handler![
@@ -271,3 +351,78 @@ fn main() {
         .run(tauri::generate_context!())
         .expect("failed to run TGLock");
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn nothing_to_share_when_the_proxy_is_off_or_local() {
+        assert_eq!(
+            share_address(None),
+            None,
+            "выключенный прокси нечего делить"
+        );
+        assert_eq!(
+            share_address(Some(ListenConfig::loopback(1080))),
+            None,
+            "на loopback снаружи никто не подключится"
+        );
+    }
+
+    #[test]
+    fn lan_mode_shares_a_reachable_address() {
+        let shown = share_address(Some(ListenConfig::lan(1443))).expect("в LAN-режиме адрес нужен");
+        assert!(shown.ends_with(":1443"), "порт должен быть виден: {shown}");
+        assert!(
+            !shown.starts_with("0.0.0.0"),
+            "0.0.0.0 нельзя вписать в Telegram: {shown}"
+        );
+        assert!(
+            !shown.starts_with("127.0.0.1"),
+            "127.0.0.1 на другом устройстве означает само устройство: {shown}"
+        );
+    }
+
+    #[test]
+    fn software_rendering_is_requested_by_default() {
+        let vars = software_rendering_vars(false, |_| false);
+        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"
+                ]
+            );
+        }
+    }
+}

src/mtproto.rs

@@ -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,23 +51,65 @@ pub fn generate_secret() -> [u8; 16] {
     secret
 }
 
-#[cfg(not(test))]
-pub fn load_or_create_secret() -> [u8; 16] {
-    let Some(path) = secret_path() else {
-        return generate_secret();
-    };
-    if let Ok(value) = std::fs::read_to_string(&path) {
-        if let Some(secret) = parse_secret_hex(value.trim()) {
-            return secret;
+/// Секрет прокси и то, лежит ли он на диске.
+pub struct StoredSecret {
+    pub value: [u8; 16],
+    /// Ошибка, из-за которой секрет не удалось сохранить.
+    ///
+    /// Если она есть, при следующем запуске секрет будет другим, ссылка
+    /// `tg://proxy` перестанет совпадать с сохранённой в Telegram, и Telegram
+    /// скажет «прокси настроен неверно и будет отключён». Раньше запись
+    /// провалившись молчала, и понять причину было невозможно
+    /// (by-sonic/tglock#37).
+    pub write_error: Option<String>,
+}
+
+impl StoredSecret {
+    /// Секрет действительно переживёт перезапуск.
+    pub fn is_persistent(&self) -> bool {
+        self.write_error.is_none()
+    }
+}
+
+/// Взять секрет из файла, создав его, если файла нет или он испорчен.
+///
+/// Секрет — половина ссылки `tg://proxy`, поэтому сервис, придумывающий новый
+/// при каждом старте, отключает всех уже настроенных клиентов.
+pub fn load_or_create_secret_at(path: &Path) -> StoredSecret {
+    if let Ok(value) = std::fs::read_to_string(path) {
+        if let Some(value) = parse_secret_hex(value.trim()) {
+            return StoredSecret {
+                value,
+                write_error: None,
+            };
         }
     }
 
-    let secret = generate_secret();
+    let value = generate_secret();
+    let write_error = store_secret(path, &secret_hex(&value))
+        .err()
+        .map(|error| format!("{}: {error}", path.display()));
+    StoredSecret { value, write_error }
+}
+
+fn store_secret(path: &Path, value: &str) -> std::io::Result<()> {
     if let Some(parent) = path.parent() {
-        let _ = std::fs::create_dir_all(parent);
+        if !parent.as_os_str().is_empty() {
+            std::fs::create_dir_all(parent)?;
+        }
+    }
+    write_secret_file(path, value)
+}
+
+#[cfg(not(test))]
+pub fn load_or_create_secret() -> StoredSecret {
+    match secret_path() {
+        Some(path) => load_or_create_secret_at(&path),
+        None => StoredSecret {
+            value: generate_secret(),
+            write_error: Some("не удалось определить папку для секрета в этой системе".to_owned()),
+        },
     }
-    write_secret_file(&path, &secret_hex(&secret));
-    secret
 }
 
 #[cfg(not(test))]
@@ -94,24 +137,22 @@ fn secret_path() -> Option<PathBuf> {
     }
 }
 
-#[cfg(all(not(test), unix))]
-fn write_secret_file(path: &std::path::Path, value: &str) {
+#[cfg(unix)]
+fn write_secret_file(path: &Path, value: &str) -> std::io::Result<()> {
     use std::io::Write;
     use std::os::unix::fs::OpenOptionsExt;
-    if let Ok(mut file) = std::fs::OpenOptions::new()
+    let mut file = std::fs::OpenOptions::new()
         .create(true)
         .truncate(true)
         .write(true)
         .mode(0o600)
-        .open(path)
-    {
-        let _ = file.write_all(value.as_bytes());
-    }
+        .open(path)?;
+    file.write_all(value.as_bytes())
 }
 
-#[cfg(all(not(test), not(unix)))]
-fn write_secret_file(path: &std::path::Path, value: &str) {
-    let _ = std::fs::write(path, value);
+#[cfg(not(unix))]
+fn write_secret_file(path: &Path, value: &str) -> std::io::Result<()> {
+    std::fs::write(path, value)
 }
 
 pub fn secret_hex(secret: &[u8; 16]) -> String {
@@ -123,6 +164,19 @@ pub fn secret_hex(secret: &[u8; 16]) -> String {
     output
 }
 
+/// Разобрать секрет, записанный человеком.
+///
+/// Принимает и 32 hex-символа, и форму с префиксом `dd` — именно так секрет
+/// выглядит в ссылке `tg://proxy`, откуда его и копируют.
+pub fn parse_secret(value: &str) -> Option<[u8; 16]> {
+    let trimmed = value.trim();
+    let hex = trimmed
+        .strip_prefix("dd")
+        .filter(|rest| rest.len() == 32)
+        .unwrap_or(trimmed);
+    parse_secret_hex(hex)
+}
+
 fn parse_secret_hex(value: &str) -> Option<[u8; 16]> {
     if value.len() != 32 {
         return None;
@@ -255,6 +309,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 +418,232 @@ 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 a_failed_write_is_reported_instead_of_swallowed() {
+        // Раньше ошибка записи выбрасывалась, секрет генерировался заново при
+        // каждом запуске, и Telegram говорил «прокси настроен неверно» без
+        // единой подсказки почему (by-sonic/tglock#37).
+        let blocker = std::env::temp_dir().join(format!(
+            "tglock-not-a-dir-{}-{:?}",
+            std::process::id(),
+            std::thread::current().id()
+        ));
+        std::fs::write(&blocker, "я файл, а не папка").unwrap();
+
+        // Родитель пути — обычный файл, поэтому создать каталог невозможно.
+        let stored = load_or_create_secret_at(&blocker.join("secret"));
+
+        assert!(
+            !stored.is_persistent(),
+            "неудачная запись обязана быть видна"
+        );
+        let error = stored.write_error.expect("должно быть сообщение об ошибке");
+        assert!(
+            error.contains("secret"),
+            "в сообщении должен быть путь, получено: {error}"
+        );
+        // Секрет всё равно выдан: прокси работает, просто до перезапуска.
+        assert_ne!(stored.value, [0; 16]);
+
+        let _ = std::fs::remove_file(&blocker);
+    }
+
+    #[test]
+    fn a_successful_write_reports_no_error() {
+        let path = std::env::temp_dir().join(format!(
+            "tglock-secret-ok-{}-{:?}",
+            std::process::id(),
+            std::thread::current().id()
+        ));
+        let _ = std::fs::remove_file(&path);
+
+        let first = load_or_create_secret_at(&path);
+        assert!(first.is_persistent(), "запись в temp должна удаваться");
+
+        // Второй запуск читает готовый файл и тоже не жалуется.
+        let second = load_or_create_secret_at(&path);
+        assert!(second.is_persistent());
+        assert_eq!(
+            first.value, second.value,
+            "секрет должен переживать перезапуск"
+        );
+
+        let _ = std::fs::remove_file(&path);
+    }
+
+    #[test]
+    fn accepts_a_secret_copied_from_a_tg_link() {
+        let expected = [
+            0x00, 0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77, 0x88, 0x99, 0xaa, 0xbb, 0xcc, 0xdd,
+            0xee, 0xff,
+        ];
+        // Обе формы: как в файле и как в ссылке tg://proxy.
+        assert_eq!(
+            parse_secret("00112233445566778899aabbccddeeff"),
+            Some(expected)
+        );
+        assert_eq!(
+            parse_secret("dd00112233445566778899aabbccddeeff"),
+            Some(expected)
+        );
+        // Пробелы по краям — обычное дело при копировании.
+        assert_eq!(
+            parse_secret("  dd00112233445566778899aabbccddeeff\n"),
+            Some(expected)
+        );
+        // Секрет, который сам начинается с dd и уже имеет полную длину, не
+        // должен потерять первый байт: префикс снимается только если после него
+        // остаётся ровно 32 символа.
+        assert_eq!(
+            parse_secret("dd112233445566778899aabbccddeeff"),
+            Some([
+                0xdd, 0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77, 0x88, 0x99, 0xaa, 0xbb, 0xcc, 0xdd,
+                0xee, 0xff,
+            ])
+        );
+    }
+
+    #[test]
+    fn rejects_malformed_secrets() {
+        for bad in [
+            "",
+            "dd",
+            "слишком коротко",
+            "00112233445566778899aabbccddee",     // 30 символов
+            "00112233445566778899aabbccddeeffff", // 34 символа
+            "zz112233445566778899aabbccddeeff",   // не hex
+        ] {
+            assert!(parse_secret(bad).is_none(), "{bad:?} должен быть отвергнут");
+        }
+    }
+
     #[test]
     fn parses_persisted_secret() {
         assert_eq!(

src/telegram_net.rs

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

src/transport.rs

@@ -1,4 +1,5 @@
 use std::collections::HashMap;
+use std::sync::atomic::{AtomicU32, Ordering};
 use std::sync::Mutex;
 use std::time::{Duration, Instant};
 
@@ -9,6 +10,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 +31,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 +67,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 +114,36 @@ struct HealthState {
 pub struct TransportEngine {
     health: Mutex<HealthState>,
     worker_domains: Mutex<Vec<String>>,
+    /// Сколько раз отдельный маршрут не ответил.
+    ///
+    /// Считается отдельно от `Stats::ws_failures`, который растёт только когда
+    /// упали ВСЕ маршруты. Из-за этого диагностика показывала «сбоев 0», пока
+    /// закреплённый адрес был недоступен и каждое холодное соединение молча
+    /// откатывалось на следующий маршрут, тратя на это до восьми секунд
+    /// (by-sonic/tglock#32).
+    route_failures: AtomicU32,
+    #[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 +237,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 {
-                connect_host: domain.clone(),
-                websocket_host: domain.clone(),
-                path: format!("/apiws?dst={}&dc={}", destination, key.dc),
-                kind: RouteKind::CloudflareWorker,
-            });
+            let path = path.clone();
+            routes.push(Route::https(
+                domain.clone(),
+                domain.clone(),
+                path,
+                RouteKind::CloudflareWorker,
+            ));
         }
         routes
     }
@@ -180,7 +267,13 @@ impl TransportEngine {
         health.preferred.insert(key, route.clone());
     }
 
+    /// Сколько отдельных маршрутов не ответило за время работы.
+    pub fn route_failures(&self) -> u32 {
+        self.route_failures.load(Ordering::Relaxed)
+    }
+
     fn record_failure(&self, route: &Route) {
+        self.route_failures.fetch_add(1, Ordering::Relaxed);
         let mut health = self.health.lock().unwrap();
         let failures = health
             .routes
@@ -200,6 +293,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 +349,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 {
-                connect_host: (*ip).to_owned(),
-                websocket_host: websocket_host.clone(),
-                path: "/apiws".to_owned(),
-                kind: if index == 0 {
+            routes.push(Route::https(
+                (*ip).to_owned(),
+                websocket_host.clone(),
+                "/apiws".to_owned(),
+                if index == 0 {
                     RouteKind::TelegramIp
                 } else {
                     RouteKind::AlternateTelegramIp
                 },
-            });
+            ));
         }
-        routes.push(Route {
-            connect_host: websocket_host.clone(),
-            websocket_host: websocket_host.clone(),
-            path: "/apiws".to_owned(),
-            kind: RouteKind::SystemDns,
-        });
+        routes.push(Route::https(
+            websocket_host.clone(),
+            websocket_host.clone(),
+            "/apiws".to_owned(),
+            RouteKind::SystemDns,
+        ));
     }
     routes
 }
@@ -258,7 +373,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 +381,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 +394,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 +502,267 @@ 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 every_route_failure_is_counted() {
+        // Диагностика показывала «сбоев 0», пока закреплённый адрес был мёртв и
+        // соединения молча откатывались на запасной. Счётчик маршрутов должен
+        // видеть каждое такое падение.
+        let engine = TransportEngine::new();
+        let routes = routes_for_dc(2, false);
+        assert_eq!(engine.route_failures(), 0);
+
+        engine.record_failure(&routes[0]);
+        assert_eq!(engine.route_failures(), 1);
+
+        engine.record_failure(&routes[0]);
+        engine.record_failure(&routes[1]);
+        assert_eq!(
+            engine.route_failures(),
+            3,
+            "считаются все падения, включая повторные по тому же маршруту"
+        );
+
+        // Успех не обнуляет историю: она нужна, чтобы понять, что маршруты
+        // перебирались, даже когда в итоге всё соединилось.
+        engine.record_success(
+            DcKey {
+                dc: 2,
+                media: false,
+            },
+            &routes[1],
+        );
+        assert_eq!(engine.route_failures(), 3);
+    }
+
+    #[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() {

tauri.conf.json

@@ -1,8 +1,9 @@
 {
   "$schema": "https://schema.tauri.app/config/2",
   "productName": "TGLock",
-  "version": "2.0.0-beta.1",
+  "version": "2.0.0-beta.10",
   "identifier": "com.bysonic.tglock",
+  "mainBinaryName": "tglock",
   "build": {
     "beforeDevCommand": "npm run dev",
     "devUrl": "http://localhost:1420",
@@ -33,6 +34,13 @@
   "bundle": {
     "active": true,
     "targets": ["app", "dmg"],
+    "icon": [
+      "icons/32x32.png",
+      "icons/128x128.png",
+      "icons/128x128@2x.png",
+      "icons/icon.icns",
+      "icons/icon.ico"
+    ],
     "category": "Utility",
     "shortDescription": "Telegram connectivity through a local MTProto proxy",
     "longDescription": "TGLock restores Telegram connectivity through an adaptive WebSocket tunnel.",

tglock.example.toml

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

ui/main.ts

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

ui/styles.css

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

worker/tglock-worker.js

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