chore(release): 2.0.0-beta.6

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

.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,40 @@ 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
@@ -53,13 +107,13 @@ jobs:
       # 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 --lib --bins --all-targets -- -D warnings
+        run: cargo clippy --no-default-features --features cli --all-targets -- -D warnings
 
       - name: Test
-        run: cargo test --no-default-features --lib --bins
+        run: cargo test --no-default-features --features cli --lib --bins
 
       - name: Build
-        run: cargo build --release --no-default-features --bin tglock-cli
+        run: cargo build --release --no-default-features --features cli --bin tglock-cli
 
       - name: Start, advertise a proxy link and stop on SIGTERM
         run: |
@@ -81,6 +135,43 @@ jobs:
             ./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
@@ -103,7 +194,7 @@ jobs:
         run: cargo check --locked
 
       - name: Check the headless dependency graph too
-        run: cargo check --locked --no-default-features --lib --bins
+        run: cargo check --locked --no-default-features --features cli --lib --bins
 
   frontend:
     name: Frontend

.github/workflows/release.yml

@@ -72,9 +72,38 @@ jobs:
             - Linux: скачайте `.AppImage` или `.deb`
             - Сервер или машина без монитора: скачайте `tglock-cli-*` — там нет графического интерфейса
           releaseDraft: false
-          prerelease: true
+          prerelease: false
           args: ${{ matrix.args }}
 
+      # Проверяет СОДЕРЖИМОЕ упакованного бинаря, а не его имя.
+      #
+      # v2.0.0-beta.2 и v2.0.0-beta.3 опубликовались с зелёным CI, хотя в бандле
+      # лежал headless CLI вместо приложения. В beta.3 имя файла было уже
+      # правильным — переименованным — поэтому проверка имени прошла. Отличить
+      # можно только по содержимому: `wry`/`ipc.localhost` есть исключительно в
+      # GUI, а `allow-direct` — исключительно в CLI.
+      - name: The bundled binary must actually be the GUI one
+        if: runner.os == 'macOS'
+        shell: bash
+        run: |
+          app=$(find target -maxdepth 6 -name 'TGLock.app' -type d | head -1)
+          test -n "$app" || { echo "TGLock.app не найден"; exit 1; }
+          exe="$app/Contents/MacOS/tglock"
+          test -f "$exe" || { echo "нет $exe:"; ls -la "$app/Contents/MacOS/"; exit 1; }
+          python3 scripts/verify_bundle_binary.py "$exe"
+
+      - name: The bundled binary must actually be the GUI one
+        if: runner.os == 'Linux'
+        shell: bash
+        run: |
+          deb=$(find target -maxdepth 6 -name '*.deb' | head -1)
+          test -n "$deb" || { echo ".deb не найден"; exit 1; }
+          root=$(mktemp -d)
+          dpkg-deb -x "$deb" "$root"
+          exe="$root/usr/bin/tglock"
+          test -f "$exe" || { echo "нет /usr/bin/tglock:"; dpkg-deb -c "$deb" | grep '/bin/'; exit 1; }
+          python3 scripts/verify_bundle_binary.py "$exe"
+
   cli:
     name: Headless CLI ${{ matrix.platform }}
     needs: publish
@@ -113,7 +142,7 @@ jobs:
           IFS=',' read -ra targets <<< "${{ matrix.rust-targets }}"
           binaries=()
           for target in "${targets[@]}"; do
-            cargo build --release --locked --no-default-features \
+            cargo build --release --locked --no-default-features --features cli \
               --bin tglock-cli --target "$target"
             binaries+=("target/$target/release/tglock-cli")
           done
@@ -129,7 +158,7 @@ jobs:
         if: runner.os == 'Windows'
         shell: bash
         run: |
-          cargo build --release --locked --no-default-features \
+          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
@@ -140,5 +169,5 @@ jobs:
           GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
         with:
           tag_name: ${{ github.ref_name }}
-          prerelease: true
+          prerelease: false
           files: ${{ matrix.asset }}

Cargo.lock

@@ -3553,7 +3553,7 @@ dependencies = [
 
 [[package]]
 name = "tglock"
-version = "2.0.0-beta.2"
+version = "2.0.0-beta.6"
 dependencies = [
  "aes",
  "cipher",
@@ -3570,6 +3570,7 @@ dependencies = [
  "tauri-build",
  "tokio",
  "tokio-tungstenite",
+ "toml 0.8.2",
 ]
 
 [[package]]

Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "tglock"
-version = "2.0.0-beta.2"
+version = "2.0.0-beta.6"
 edition = "2021"
 rust-version = "1.88"
 description = "Telegram unblock via local WebSocket tunnel"
@@ -13,6 +13,14 @@ default = ["gui"]
 # 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"
@@ -26,11 +34,15 @@ required-features = ["gui"]
 [[bin]]
 name = "tglock-cli"
 path = "src/bin/cli.rs"
+required-features = ["cli"]
 
 [dependencies]
 tauri = { version = "2", features = [], optional = true }
 open = { version = "5", optional = true }
-clap = { version = "4", features = ["derive"] }
+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 = [

README.md

@@ -80,22 +80,54 @@ TGLock — это **локальный прокси** на твоём компь
 
 **[👉 Последний релиз](https://github.com/by-sonic/tglock/releases/latest)**
 
-| Платформа | Файл | Размер |
-|---|---|---|
-| **Windows 10/11** (x64) | `_x64-setup.exe` | ~2 МБ |
-| **macOS** (Apple Silicon + Intel) | universal `.dmg` | ~7 МБ |
-| **Linux** (x86_64) | `.deb` | ~3 МБ |
-| **Linux** (x86_64, портативно) | `.AppImage` | ~79 МБ |
+| Платформа | Файл |
+|---|---|
+| **Windows 10/11** (x64) | `_x64-setup.exe` |
+| **macOS** (Apple Silicon + Intel) | universal `.dmg` |
+| **Linux** (x86_64) | `.deb` |
+| **Linux** (x86_64, портативно) | `.AppImage` |
+| **Сервер, контейнер, машина без монитора** | `tglock-cli-*` |
 
-> **🖥 `tglock-cli`** — тот же туннель без графического интерфейса, одним бинарём. Нужен там, где окно просто не создаётся: сервер, контейнер, виртуалка, машина без монитора или без 3D-ускорения.
->
-> Он есть в `main` и собирается одной командой, а в готовые сборки релиза попадёт начиная со следующего тега:
->
-> ```bash
-> cargo build --release --locked --no-default-features --bin tglock-cli
-> ```
->
-> Подробности — [ниже](#-без-графического-интерфейса-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
@@ -137,10 +169,34 @@ Telegram → Настройки → **Продвинутые** → Тип сое
 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    # резервный маршрут через свой Cloudflare Worker
+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 настроился сам. Дальше в лог идёт по строке на каждое изменение состояния: сколько соединений, какой дата-центр, какой маршрут живой, сколько сбоев.
 
 Прав администратора не нужно: TGLock не правит ни системный DNS, ни файл `hosts` — нужные адреса Telegram зашиты в маршрутах, а TLS SNI остаётся настоящим.
@@ -157,7 +213,7 @@ Wants=network-online.target
 
 [Service]
 Type=exec
-ExecStart=/usr/local/bin/tglock-cli --lan --secret-file /var/lib/tglock/secret
+ExecStart=/usr/local/bin/tglock-cli --config /etc/tglock.toml
 Restart=on-failure
 RestartSec=5s
 StateDirectory=tglock
@@ -174,11 +230,14 @@ 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
 ```
 
-`--secret-file` здесь обязателен, и это не украшение: секрет — половина `tg://proxy`-ссылки. Без файла он генерируется заново при каждом старте, и после первого же `systemctl restart` все настроенные клиенты перестанут подключаться. `StateDirectory=tglock` создаёт `/var/lib/tglock` с нужными правами, а сам файл пишется с режимом `600`.
+**Закреплённый секрет здесь обязателен**, и это не украшение: секрет — половина `tg://proxy`-ссылки. Без него он генерируется заново при каждом старте, и после первого же `systemctl restart` все настроенные клиенты перестанут подключаться. Задайте `secret` в `/etc/tglock.toml` (файл с правами `600`) либо `secret_file = "/var/lib/tglock/secret"` — тогда `StateDirectory=tglock` создаст каталог с нужными правами, а файл запишется с режимом `600`.
+
+При старте без закреплённого секрета CLI печатает предупреждение — молча уйти в такое состояние он не даст.
 
 Остановка по `systemctl stop` приходит как `SIGTERM` — CLI закрывает туннели и выходит с нулевым кодом, а не умирает по `SIGKILL`.
 
@@ -188,7 +247,7 @@ journalctl -u tglock -f
 FROM rust:1.88 AS build
 WORKDIR /src
 COPY . .
-RUN cargo build --release --locked --no-default-features --bin tglock-cli
+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 \
@@ -233,7 +292,7 @@ Telegram Desktop / mobile (через LAN)
 
 > Интерфейс различает три состояния и не выдаёт одно за другое: **«Защита включена»** — локальный порт открыт, туннеля пока нет; **«Ищем новый маршрут»** — попытки были неудачными, идёт перебор; **«Telegram на связи»** — есть установленный туннель, то есть WebSocket-рукопожатие уже прошло. Смешивание первого и третьего состояния и было основной причиной жалоб «прокси подключён, а Telegram не работает».
 
-📖 **Архитектура 2.0, различение протоколов и честный список ограничений** — [docs/ARCHITECTURE_V2.md](docs/ARCHITECTURE_V2.md). Разбор всех issue и того, что в них было обещано зря — [docs/ISSUE_AUDIT.md](docs/ISSUE_AUDIT.md). Черновик статьи про переход v1 → v2 лежит в [HABR.md](HABR.md) — цифры там описывают код на момент написания, документацией он не является.
+📖 **Архитектура 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) — цифры там описывают код на момент написания, документацией он не является.
 
 ---
 
@@ -344,9 +403,13 @@ xattr -cr /Applications/TGLock.app
 
 Это реальный риск, и TGLock 2.0 к нему подготовлен настолько, насколько может.
 
-Маршрут не один: пробуются закреплённые IP Telegram, дублёры `kwsN-1` и системный DNS. Пока жив хотя бы один — туннель поднимается. Дополнительно можно указать в настройках **свой Cloudflare Worker** — тогда соединение пойдёт через твой домен на `workers.dev`, и заблокировать его провайдеру придётся отдельно.
+Маршрут не один: пробуются закреплённые IP Telegram, дублёры `kwsN-1` и системный DNS. Пока жив хотя бы один — туннель поднимается.
 
-Но честно: если веб-версию Telegram заблокируют целиком, подход исчерпает себя. TGLock держится на том, что `web.telegram.org` доступен, и никакой запас маршрутов этого не отменяет. В таком случае нужен полноценный VPN — это уже другая задача.
+Если у твоего провайдера легли **все** маршруты, есть запасной выход — **свой Cloudflare Worker**. Тогда соединение идёт на твой домен `*.workers.dev`, а воркер доводит его до Telegram; блокировать его провайдеру придётся отдельно. Готовый скрипт и пошаговая установка: **[docs/CLOUDFLARE_WORKER.md](docs/CLOUDFLARE_WORKER.md)**. Нужен только аккаунт Cloudflare, бесплатного тарифа хватает, свой сервер и домен не нужны.
+
+Признак, что пора это делать: приложение показывает «Ищем новый маршрут» и не проходит, а в диагностике туннелей 0 и растёт счётчик сбоев. Если Telegram работает — настраивать ничего не надо.
+
+Но честно: если веб-версию Telegram заблокируют так, что её не видно и из датацентров Cloudflare, подход исчерпает себя. TGLock держится на доступности `web.telegram.org`, и никакой запас маршрутов этого не отменяет.
 </details>
 
 <details>
@@ -399,7 +462,7 @@ npm run tauri build
 ### Только CLI, без графики
 
 ```bash
-cargo build --release --locked --no-default-features --bin tglock-cli
+cargo build --release --locked --no-default-features --features cli --bin tglock-cli
 ```
 
 Ни Node.js, ни фронтенда, ни `libwebkit2gtk` для этого не нужно — при выключенной фиче `gui` Tauri и системный WebView в сборку не попадают вообще. Именно так CLI собирается на голом сервере.
@@ -409,9 +472,9 @@ cargo build --release --locked --no-default-features --bin tglock-cli
 ```bash
 cargo fmt --check
 cargo clippy --all-targets -- -D warnings
-cargo clippy --no-default-features --lib --bins --all-targets -- -D warnings
+cargo clippy --no-default-features --features cli --all-targets -- -D warnings
 cargo test --all-targets
-cargo test --no-default-features --lib --bins
+cargo test --no-default-features --features cli --lib --bins
 ```
 
 Тестов 59: разбор `obfuscated2`, каскад маршрутов и его cooldown, протокольные отказы SOCKS5, устойчивость секрета к перезапуску, плюс сквозной тест туннеля против мок-сервера, который реализует сторону Telegram и проверяет, что до неё доходит ровно тот открытый текст, который отправил клиент. Единственный тест с пометкой `#[ignore]` — тот, что требует живой сети.

docs/ARCHITECTURE_V2.md

@@ -118,10 +118,14 @@ Worker должен принимать WebSocket на:
   заданные оператором значения не перезаписываются, а `TGLOCK_FORCE_GPU=1`
   возвращает аппаратное ускорение. Для машин без монитора остаётся
   `tglock-cli`, которому WebView не нужен вовсе (issues #10, #17).
-- Windows-инсталлятор не подписан, macOS-сборка не нотарифицирована. Часть
-  антивирусов реагирует на неподписанный установщик, открывающий локальный
-  сокет; проверяемый ответ — сборка из исходников либо публичные логи
-  GitHub Actions.
+- 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

@@ -14,11 +14,21 @@
 >   больше нет, и правил системный DNS. Взято разделение GUI/CLI и произвольный
 >   bind-адрес; DNS-менеджмент и проверка root отброшены как ненужные.
 > - #12 закрыт: относился к шрифту старого egui-интерфейса.
-> - #10 и #17 **оставлены открытыми осознанно.** Появился headless `tglock-cli`,
->   который на таких машинах работает, но сам GUI по-прежнему не создаёт окно
->   без 3D-ускорения. Это обход, а не исправление.
-> - #9 (Android) остаётся в backlog без сроков, #21 ждёт подтверждения на
->   пересобранной сборке macOS.
+> - #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-ветку и умирало),

package.json

@@ -1,7 +1,7 @@
 {
   "name": "tglock-ui",
   "private": true,
-  "version": "2.0.0-beta.2",
+  "version": "2.0.0-beta.6",
   "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

@@ -12,11 +12,22 @@ use std::process::ExitCode;
 use std::sync::atomic::Ordering;
 use std::sync::Arc;
 use std::time::Duration;
-use tglock::config::ListenConfig;
-use tglock::{mtproto, proxy, transport};
+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",
@@ -24,13 +35,17 @@ const STATUS_POLL: Duration = Duration::from_secs(1);
     about = "TGLock без графического интерфейса: локальный MTProto-прокси через WebSocket"
 )]
 struct Args {
-    /// Адрес для прослушивания. 127.0.0.1 — только этот компьютер
-    #[arg(short, long, value_name = "IP", default_value = "127.0.0.1")]
-    bind: IpAddr,
+    /// Файл настроек. Если не задан, ищется tglock.toml рядом с бинарём
+    #[arg(short, long, value_name = "PATH")]
+    config: Option<PathBuf>,
 
-    /// Порт локального прокси
-    #[arg(short, long, value_name = "PORT", default_value_t = proxy::DEFAULT_PORT)]
-    port: u16,
+    /// Адрес для прослушивания. По умолчанию 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")]
@@ -44,8 +59,8 @@ struct Args {
     #[arg(long)]
     allow_direct: bool,
 
-    /// Файл с секретом прокси. Обязателен для сервиса: иначе после перезапуска
-    /// секрет будет новым и уже настроенные клиенты перестанут подключаться
+    /// Файл с секретом прокси. Для сервиса нужен он или secret в настройках:
+    /// иначе после перезапуска секрет будет новым и настроенные клиенты отвалятся
     #[arg(long, value_name = "PATH")]
     secret_file: Option<PathBuf>,
 
@@ -55,28 +70,31 @@ struct Args {
 }
 
 impl Args {
-    fn stats(&self) -> Arc<proxy::Stats> {
-        match &self.secret_file {
-            Some(path) => proxy::Stats::with_secret(mtproto::load_or_create_secret_at(path)),
-            None => proxy::Stats::new(),
+    fn 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,
         }
     }
 
-    fn listen(&self) -> ListenConfig {
-        let base = if self.lan {
-            ListenConfig::lan(self.port)
-        } else {
-            ListenConfig::new(self.bind, self.port)
-        };
-        if self.allow_direct {
-            base.with_allow_direct(true)
-        } else {
-            base
+    /// Файл настроек и путь, по которому он найден.
+    ///
+    /// Явный `--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 worker_domains(&self) -> String {
-        self.worker.join(",")
     }
 }
 
@@ -100,30 +118,46 @@ fn main() -> ExitCode {
 }
 
 async fn serve(args: Args) -> Result<(), String> {
-    let listen = args.listen();
-    let stats = args.stats();
-    stats.set_worker_domain(&args.worker_domains());
+    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 !args.quiet {
-        println!("Слушаю {}", listen.addr);
-        println!(
+    if !quiet {
+        let intro = match &file_path {
+            Some(path) => format!("Настройки: {}", path.display()),
+            None => format!(
+                "Настройки: только флаги ({} рядом с бинарём не найден)",
+                config::DEFAULT_FILE_NAME
+            ),
+        };
+        say(&intro);
+        say(&format!("Слушаю {}", listen.addr));
+        say(&format!(
             "Ссылка для Telegram: {}",
             listen.telegram_link(&stats.telegram_secret())
-        );
-        if listen.allow_direct && !listen.addr.ip().is_loopback() {
-            println!(
-                "Внимание: --allow-direct на адресе {} превращает TGLock в открытый SOCKS5-прокси",
-                listen.addr.ip()
+        ));
+        if matches!(settings.secret, config::SecretSource::Ephemeral) {
+            say(
+                "Внимание: секрет не закреплён и будет новым после перезапуска — \
+                 задайте secret в настройках или --secret-file",
             );
-        } else if !listen.allow_direct {
-            println!("Пропускаю только адреса Telegram");
         }
-        if !args.worker.is_empty() {
-            println!("Резервные Worker-домены: {}", args.worker_domains());
+        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));
         }
     }
 
@@ -132,14 +166,14 @@ async fn serve(args: Args) -> Result<(), String> {
         tokio::spawn(
             async move { proxy::serve(server_stats, listener, listen.allow_direct).await },
         );
-    let watcher = (!args.quiet).then(|| tokio::spawn(watch_status(stats.clone())));
+    let 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 !args.quiet {
-                println!("Получен сигнал остановки, закрываю соединения…");
+            if !quiet {
+                say("Получен сигнал остановки, закрываю соединения…");
             }
             stats.stop();
             server
@@ -173,7 +207,7 @@ async fn watch_status(stats: Arc<proxy::Stats>) {
             continue;
         }
         let (active, tunnels, dc, route, failures) = current;
-        println!(
+        let line = format!(
             "соединений {active} · туннелей {tunnels} · {} · {} · сбоев {failures}",
             if dc > 0 {
                 format!("DC{dc}")
@@ -182,6 +216,11 @@ async fn watch_status(stats: Arc<proxy::Stats>) {
             },
             transport::route_label(route)
         );
+        // Закрытый stdout — не ошибка: печатать больше некому, туннель работает
+        // дальше без наблюдателя.
+        if !say(&line) {
+            return;
+        }
         previous = Some(current);
     }
 }
@@ -213,6 +252,11 @@ mod tests {
         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();
@@ -220,7 +264,7 @@ mod tests {
 
     #[test]
     fn defaults_to_loopback_on_the_default_port() {
-        let listen = parse(&[]).listen();
+        let listen = from_flags(&[]).listen;
         assert_eq!(listen.addr.to_string(), "127.0.0.1:1080");
         assert!(listen.allow_direct);
     }
@@ -228,50 +272,50 @@ mod tests {
     #[test]
     fn lan_flag_matches_explicit_wildcard_bind() {
         assert_eq!(
-            parse(&["--lan"]).listen(),
-            parse(&["-b", "0.0.0.0"]).listen()
+            from_flags(&["--lan"]).listen,
+            from_flags(&["-b", "0.0.0.0"]).listen
         );
     }
 
     #[test]
     fn lan_does_not_relay_non_telegram_traffic() {
-        let listen = parse(&["--lan"]).listen();
+        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!(!parse(&["-b", "192.168.1.10"]).listen().allow_direct);
+        assert!(!from_flags(&["-b", "192.168.1.10"]).listen.allow_direct);
         assert!(
-            parse(&["-b", "192.168.1.10", "--allow-direct"])
-                .listen()
+            from_flags(&["-b", "192.168.1.10", "--allow-direct"])
+                .listen
                 .allow_direct
         );
     }
 
     #[test]
     fn bind_and_port_are_honoured() {
-        let listen = parse(&["--bind", "10.0.0.7", "--port", "1443"]).listen();
+        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 = parse(&["-b", "::1", "-p", "2080"]).listen();
+        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 args = parse(&["--worker", "a.workers.dev", "--worker", "b.workers.dev"]);
-        assert_eq!(args.worker_domains(), "a.workers.dev,b.workers.dev");
+        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!(parse(&[]).worker_domains().is_empty());
+        assert!(from_flags(&[]).workers.is_empty());
     }
 
     #[test]
@@ -288,10 +332,10 @@ mod tests {
         ));
         let _ = std::fs::remove_file(&path);
 
-        let first = parse(&["--secret-file", path.to_str().unwrap()])
+        let first = from_flags(&["--secret-file", path.to_str().unwrap()])
             .stats()
             .telegram_secret();
-        let second = parse(&["--secret-file", path.to_str().unwrap()])
+        let second = from_flags(&["--secret-file", path.to_str().unwrap()])
             .stats()
             .telegram_secret();
 
@@ -303,11 +347,11 @@ mod tests {
 
         // A corrupted file must not wedge the daemon: it is replaced.
         std::fs::write(&path, "garbage").unwrap();
-        let third = parse(&["--secret-file", path.to_str().unwrap()])
+        let third = from_flags(&["--secret-file", path.to_str().unwrap()])
             .stats()
             .telegram_secret();
         assert_ne!(third, first);
-        let fourth = parse(&["--secret-file", path.to_str().unwrap()])
+        let fourth = from_flags(&["--secret-file", path.to_str().unwrap()])
             .stats()
             .telegram_secret();
         assert_eq!(third, fourth, "the replacement must be persisted in turn");

src/cli_settings.rs

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

src/lib.rs

@@ -9,3 +9,7 @@ pub mod config;
 pub mod mtproto;
 pub mod proxy;
 pub mod transport;
+
+/// Настройки headless-версии: файл конфигурации и сведение с флагами.
+#[cfg(feature = "cli")]
+pub mod cli_settings;

src/mtproto.rs

@@ -133,6 +133,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;
@@ -501,6 +514,52 @@ mod tests {
         }
     }
 
+    #[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/proxy.rs

@@ -561,31 +561,38 @@ mod tests {
     /// Stand-in for `kwsN.web.telegram.org`: a plaintext WebSocket that behaves
     /// like an obfuscated2 relay.
     ///
-    /// Returns the raw init frame it was handed and the plaintext it recovered,
-    /// so a test can assert on what Telegram would really have seen.
+    /// Returns the URI it was asked for, the raw init frame it was handed and
+    /// the plaintext it recovered, so a test can assert on what Telegram — or a
+    /// Cloudflare Worker standing in for it — would really have seen.
     // The handshake callback's error type is tungstenite's own `ErrorResponse`,
     // whose size is not ours to change.
     #[allow(clippy::result_large_err)]
     async fn mock_relay(
         listener: TcpListener,
         response: Vec<u8>,
-    ) -> Result<(Vec<u8>, Vec<u8>), String> {
+    ) -> Result<(String, Vec<u8>, Vec<u8>), String> {
         use futures_util::{SinkExt, StreamExt};
 
         let (tcp, _) = listener.accept().await.map_err(|e| e.to_string())?;
+        let requested = Arc::new(Mutex::new(String::new()));
+        let seen = requested.clone();
         // Telegram confirms the `binary` subprotocol the proxy asks for, and
         // tungstenite refuses a handshake that silently drops it. A mock that
         // does not answer it would only ever test the failure path.
-        let mut websocket =
-            tokio_tungstenite::accept_hdr_async(tcp, |_: &Request, mut response: Response| {
+        let mut websocket = tokio_tungstenite::accept_hdr_async(
+            tcp,
+            move |request: &Request, mut response: Response| {
+                *seen.lock().unwrap() = request.uri().to_string();
                 response.headers_mut().insert(
                     "Sec-WebSocket-Protocol",
                     "binary".parse().expect("static header value"),
                 );
                 Ok(response)
-            })
-            .await
-            .map_err(|e| e.to_string())?;
+            },
+        )
+        .await
+        .map_err(|e| e.to_string())?;
+        let requested = requested.lock().unwrap().clone();
 
         let init = match websocket.next().await {
             Some(Ok(Message::Binary(data))) => data,
@@ -615,7 +622,7 @@ mod tests {
             .send(Message::Binary(wire))
             .await
             .map_err(|e| e.to_string())?;
-        Ok((init, request))
+        Ok((requested, init, request))
     }
 
     #[tokio::test]
@@ -896,7 +903,7 @@ mod tests {
             "the client must see Telegram's plaintext"
         );
 
-        let (init_frame, relayed) = relay.await.unwrap().unwrap();
+        let (_, init_frame, relayed) = relay.await.unwrap().unwrap();
         assert_eq!(init_frame.len(), INIT_LEN);
         assert_ne!(
             init_frame.as_slice(),
@@ -919,6 +926,60 @@ mod tests {
         let _ = server.await.unwrap();
     }
 
+    #[tokio::test]
+    async fn connects_through_the_documented_worker_contract() {
+        // Locks the contract in docs/CLOUDFLARE_WORKER.md: a server that
+        // implements exactly what is documented there must carry a working
+        // tunnel, and must be asked for exactly the documented URI.
+        let dc = 2;
+        let path = crate::transport::worker_path(dc).unwrap();
+
+        let listener = TcpListener::bind("127.0.0.1:0").await.unwrap();
+        let worker_port = listener.local_addr().unwrap().port();
+        let response = b"an answer relayed by the worker".to_vec();
+        let worker = tokio::spawn(mock_relay(listener, response.clone()));
+
+        let stats = Stats::new();
+        stats.transport.force_local_route_with(
+            worker_port,
+            crate::transport::RouteKind::CloudflareWorker,
+            path.clone(),
+        );
+        let (port, server) = start_proxy(stats.clone(), false).await;
+
+        let init = unambiguous_client_init(&stats.secret, dc as i16);
+        let mut peer = crate::mtproto::test_client_peer(&init, &stats.secret);
+        let mut client = TcpStream::connect(("127.0.0.1", port)).await.unwrap();
+        client.write_all(&init).await.unwrap();
+
+        let request = b"a request relayed to the worker".to_vec();
+        let mut wire = request.clone();
+        peer.encrypt(&mut wire);
+        client.write_all(&wire).await.unwrap();
+
+        let mut received = vec![0; response.len()];
+        tokio::time::timeout(Duration::from_secs(10), client.read_exact(&mut received))
+            .await
+            .expect("the worker's answer must come back through the tunnel")
+            .unwrap();
+        peer.decrypt(&mut received);
+        assert_eq!(received, response);
+
+        let (requested, _, relayed) = worker.await.unwrap().unwrap();
+        assert_eq!(
+            requested, path,
+            "a deployed worker must serve exactly the documented path and query"
+        );
+        assert_eq!(relayed, request);
+        assert_eq!(
+            stats.last_route.load(Ordering::Relaxed),
+            crate::transport::RouteKind::CloudflareWorker.ui_code()
+        );
+
+        stats.stop();
+        let _ = server.await.unwrap();
+    }
+
     #[tokio::test]
     async fn a_tunnel_counts_only_after_the_handshake_succeeds() {
         // Accepts TCP and then stays silent, so the WebSocket handshake never

src/transport.rs

@@ -122,11 +122,15 @@ 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: "/apiws".to_owned(),
-            kind: RouteKind::TelegramIp,
+            path,
+            kind,
             port,
             secure: false,
         }];
@@ -233,14 +237,15 @@ impl TransportEngine {
         }
 
         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() {
+            let path = path.clone();
             routes.push(Route::https(
                 domain.clone(),
                 domain.clone(),
-                format!("/apiws?dst={}&dc={}", destination, key.dc),
+                path,
                 RouteKind::CloudflareWorker,
             ));
         }
@@ -273,6 +278,28 @@ impl TransportEngine {
     }
 }
 
+/// Path a user's Cloudflare Worker must serve for the given data centre.
+///
+/// This is the contract documented in `docs/CLOUDFLARE_WORKER.md`; both the
+/// route builder and the tests derive the path from here so the documentation
+/// cannot drift away from what the client actually requests.
+pub(crate) fn worker_path(dc: u16) -> Option<String> {
+    let destination = telegram_ips(dc).first()?;
+    Some(format!("/apiws?dst={}&dc={}", destination, dc))
+}
+
+/// Every address a Worker may be asked to reach, so a deployment can refuse
+/// anything else instead of becoming an open TCP proxy.
+pub fn worker_allowed_destinations() -> Vec<&'static str> {
+    let mut all: Vec<_> = [1, 2, 3, 4, 5, 203]
+        .into_iter()
+        .flat_map(|dc| telegram_ips(dc).iter().copied())
+        .collect();
+    all.sort_unstable();
+    all.dedup();
+    all
+}
+
 fn canonical_dc(dc: u16) -> u16 {
     if dc == 203 {
         2
@@ -629,6 +656,39 @@ mod tests {
         );
     }
 
+    #[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 [

tauri.conf.json

@@ -1,8 +1,9 @@
 {
   "$schema": "https://schema.tauri.app/config/2",
   "productName": "TGLock",
-  "version": "2.0.0-beta.2",
+  "version": "2.0.0-beta.6",
   "identifier": "com.bysonic.tglock",
+  "mainBinaryName": "tglock",
   "build": {
     "beforeDevCommand": "npm run dev",
     "devUrl": "http://localhost:1420",

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

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" },
+    });
+  },
+};