diff --git a/.github/workflows/build.yml b/.github/workflows/build.yml index 225018f..89e3caf 100644 --- a/.github/workflows/build.yml +++ b/.github/workflows/build.yml @@ -3,9 +3,14 @@ name: Build & Release on: workflow_dispatch: inputs: + make_release: + description: 'Create Github Release?' + type: boolean + required: true + default: false version: description: "Release version tag (e.g. v1.0.0)" - required: true + required: false default: "v1.0.0" permissions: @@ -25,20 +30,291 @@ jobs: cache: "pip" - name: Install dependencies - run: pip install -r requirements.txt + run: pip install ".[win10]" - name: Install pyinstaller - run: pip install pyinstaller + run: pip install "pyinstaller==6.13.0" - name: Build EXE with PyInstaller run: pyinstaller packaging/windows.spec --noconfirm + - name: Rename artifact + run: mv dist/TgWsProxy.exe dist/TgWsProxy_windows.exe + - name: Upload artifact uses: actions/upload-artifact@v4 with: name: TgWsProxy path: | - dist/TgWsProxy.exe + dist/TgWsProxy_windows.exe + + build-win7: + runs-on: windows-latest + steps: + - name: Checkout + uses: actions/checkout@v4 + + - name: Setup Python 3.8 (last version supporting Win7) + uses: actions/setup-python@v5 + with: + python-version: "3.8" + cache: "pip" + + - name: Install dependencies (Win7-compatible) + run: pip install ".[win7]" + + - name: Install pyinstaller + run: pip install "pyinstaller==5.13.2" + + - name: Build EXE with PyInstaller (Win7) + run: pyinstaller packaging/windows.spec --noconfirm + + - name: Rename artifact + run: mv dist/TgWsProxy.exe dist/TgWsProxy_windows_7.exe + + - name: Upload artifact + uses: actions/upload-artifact@v4 + with: + name: TgWsProxy-win7 + path: dist/TgWsProxy_windows_7.exe + + build-macos: + runs-on: macos-latest + steps: + - name: Checkout + uses: actions/checkout@v4 + + - name: Install universal2 Python + run: | + set -euo pipefail + curl -LO https://www.python.org/ftp/python/3.12.10/python-3.12.10-macos11.pkg + sudo installer -pkg python-3.12.10-macos11.pkg -target / + echo "/Library/Frameworks/Python.framework/Versions/3.12/bin" >> "$GITHUB_PATH" + + - name: Install dependencies + run: | + set -euo pipefail + python3.12 -m pip install --upgrade pip setuptools wheel + python3.12 -m pip install delocate==0.13.0 + + mkdir -p wheelhouse/arm64 wheelhouse/x86_64 wheelhouse/universal2 + + python3.12 -m pip download \ + --only-binary=:all: \ + --platform macosx_11_0_arm64 \ + --python-version 3.12 \ + --implementation cp \ + -d wheelhouse/arm64 \ + 'cffi>=2.0.0' \ + Pillow==12.1.0 \ + psutil==7.0.0 + + python3.12 -m pip download \ + --only-binary=:all: \ + --platform macosx_10_13_x86_64 \ + --python-version 3.12 \ + --implementation cp \ + -d wheelhouse/x86_64 \ + 'cffi>=2.0.0' \ + Pillow==12.1.0 + + python3.12 -m pip download \ + --only-binary=:all: \ + --platform macosx_10_9_x86_64 \ + --python-version 3.12 \ + --implementation cp \ + -d wheelhouse/x86_64 \ + psutil==7.0.0 + + delocate-merge \ + wheelhouse/arm64/cffi-*.whl \ + wheelhouse/x86_64/cffi-*.whl \ + -w wheelhouse/universal2 + + delocate-merge \ + wheelhouse/arm64/pillow-12.1.0-*.whl \ + wheelhouse/x86_64/pillow-12.1.0-*.whl \ + -w wheelhouse/universal2 + + delocate-merge \ + wheelhouse/arm64/psutil-7.0.0-*.whl \ + wheelhouse/x86_64/psutil-7.0.0-*.whl \ + -w wheelhouse/universal2 + + python3.12 -m pip install --no-deps wheelhouse/universal2/*.whl + python3.12 -m pip install ".[macos]" + python3.12 -m pip install pyinstaller==6.13.0 + + - name: Create macOS icon from ICO + run: | + set -euo pipefail + python3.12 - <<'PY' + from PIL import Image + + image = Image.open('icon.ico') + image = image.resize((1024, 1024), Image.LANCZOS) + image.save('icon_1024.png', 'PNG') + PY + + mkdir -p icon.iconset + sips -z 16 16 icon_1024.png --out icon.iconset/icon_16x16.png + sips -z 32 32 icon_1024.png --out icon.iconset/icon_16x16@2x.png + sips -z 32 32 icon_1024.png --out icon.iconset/icon_32x32.png + sips -z 64 64 icon_1024.png --out icon.iconset/icon_32x32@2x.png + sips -z 128 128 icon_1024.png --out icon.iconset/icon_128x128.png + sips -z 256 256 icon_1024.png --out icon.iconset/icon_128x128@2x.png + sips -z 256 256 icon_1024.png --out icon.iconset/icon_256x256.png + sips -z 512 512 icon_1024.png --out icon.iconset/icon_256x256@2x.png + sips -z 512 512 icon_1024.png --out icon.iconset/icon_512x512.png + sips -z 1024 1024 icon_1024.png --out icon.iconset/icon_512x512@2x.png + iconutil -c icns icon.iconset -o icon.icns + rm -rf icon.iconset icon_1024.png + + - name: Build app with PyInstaller + run: python3.12 -m PyInstaller packaging/macos.spec --noconfirm + + - name: Validate universal2 app bundle + run: | + set -euo pipefail + found=0 + while IFS= read -r -d '' file; do + if file "$file" | grep -q "Mach-O"; then + found=1 + archs="$(lipo -archs "$file" 2>/dev/null || true)" + case "$archs" in + *arm64*x86_64*|*x86_64*arm64*) ;; + *) + echo "Missing universal2 slices in $file: ${archs:-unknown}" >&2 + exit 1 + ;; + esac + fi + done < <(find "dist/TG WS Proxy.app" -type f -print0) + + if [ "$found" -eq 0 ]; then + echo "No Mach-O files found in app bundle" >&2 + exit 1 + fi + + - name: Create DMG + run: | + set -euo pipefail + APP_NAME="TG WS Proxy" + DMG_TEMP="dist/dmg_temp" + + rm -rf "$DMG_TEMP" + mkdir -p "$DMG_TEMP" + cp -R "dist/${APP_NAME}.app" "$DMG_TEMP/" + ln -s /Applications "$DMG_TEMP/Applications" + + hdiutil create \ + -volname "$APP_NAME" \ + -srcfolder "$DMG_TEMP" \ + -ov \ + -format UDZO \ + "dist/TgWsProxy_macos_universal.dmg" + + rm -rf "$DMG_TEMP" + + - name: Upload artifact + uses: actions/upload-artifact@v4 + with: + name: TgWsProxy-macOS + path: dist/TgWsProxy_macos_universal.dmg + + build-linux: + runs-on: ubuntu-latest + steps: + - name: Checkout + uses: actions/checkout@v4 + + - name: Install system dependencies + run: | + sudo apt-get update + sudo apt-get install -y \ + python3-venv \ + python3-dev \ + python3-gi \ + gir1.2-ayatanaappindicator3-0.1 \ + python3-tk + + - name: Create venv with system site-packages + run: python3 -m venv --system-site-packages .venv + + - name: Install dependencies + run: | + .venv/bin/pip install --upgrade pip + .venv/bin/pip install ".[linux]" + .venv/bin/pip install "pyinstaller==6.13.0" + + - name: Build binary with PyInstaller + run: .venv/bin/pyinstaller packaging/linux.spec --noconfirm + + - name: Rename binary artifact + run: mv dist/TgWsProxy dist/TgWsProxy_linux_amd64 + + - name: Create .deb package + run: | + set -euo pipefail + VERSION="${{ github.event.inputs.version }}" + VERSION="${VERSION#v}" + PKG_ROOT="pkg" + + rm -rf "$PKG_ROOT" + mkdir -p \ + "$PKG_ROOT/DEBIAN" \ + "$PKG_ROOT/usr/bin" \ + "$PKG_ROOT/usr/share/applications" \ + "$PKG_ROOT/usr/share/icons/hicolor/256x256/apps" + + install -m 755 dist/TgWsProxy_linux_amd64 "$PKG_ROOT/usr/bin/tg-ws-proxy" + + .venv/bin/python - < "$PKG_ROOT/usr/share/applications/tg-ws-proxy.desktop" < "$PKG_ROOT/DEBIAN/control" < [!CAUTION] > > ### Реакция антивирусов +> > Windows Defender часто ошибочно помечает приложение как **Wacatac**. > Если вы не можете скачать из-за блокировки, то: +> > 1) Попробуйте скачать версию win7 (она ничем не отличается в плане функционала) > 2) Отключите антивирус на время скачивания, добавьте файл в исключения и включите обратно > @@ -10,42 +12,65 @@ # TG WS Proxy -Локальный SOCKS5-прокси для Telegram на Windows и Android, который перенаправляет трафик через WebSocket-соединения к указанным серверам, помогая частично ускорить работу Telegram. - -**Ожидаемый результат аналогичен прокидыванию hosts для Web Telegram**: ускорение загрузки и скачивания файлов, загрузки сообщений и части медиа. +**Локальный SOCKS5-прокси** для Telegram Desktop, который **ускоряет работу Telegram**, перенаправляя трафик через WebSocket-соединения. Данные передаются в том же зашифрованном виде, а для работы не нужны сторонние сервера. image ## Как это работает ``` -Telegram Desktop → SOCKS5 (127.0.0.1:1080) → TG WS Proxy → WSS (kws*.web.telegram.org) → Telegram DC +Telegram Desktop → SOCKS5 (127.0.0.1:1080) → TG WS Proxy → WSS → Telegram DC ``` 1. Приложение поднимает локальный SOCKS5-прокси на `127.0.0.1:1080` 2. Перехватывает подключения к IP-адресам Telegram 3. Извлекает DC ID из MTProto obfuscation init-пакета -4. Устанавливает WebSocket (TLS) соединение к соответствующему DC через домены `kws{N}.web.telegram.org` +4. Устанавливает WebSocket (TLS) соединение к соответствующему DC через домены Telegram 5. Если WS недоступен (302 redirect) — автоматически переключается на прямое TCP-соединение ## 🚀 Быстрый старт ### Windows -Перейдите на [страницу релизов](https://github.com/Flowseal/tg-ws-proxy/releases) и скачайте **`TgWsProxy.exe`**. Он собирается автоматически через [Github Actions](https://github.com/Flowseal/tg-ws-proxy/actions) из открытого исходного кода. + +Перейдите на [страницу релизов](https://github.com/Flowseal/tg-ws-proxy/releases) и скачайте **`TgWsProxy_windows.exe`**. Он собирается автоматически через [Github Actions](https://github.com/Flowseal/tg-ws-proxy/actions) из открытого исходного кода. При первом запуске откроется окно с инструкцией по подключению Telegram Desktop. Приложение сворачивается в системный трей. **Меню трея:** + - **Открыть в Telegram** — автоматически настроить прокси через `tg://socks` ссылку - **Перезапустить прокси** — перезапуск без выхода из приложения - **Настройки...** — GUI-редактор конфигурации - **Открыть логи** — открыть файл логов - **Выход** — остановить прокси и закрыть приложение +### macOS + +Перейдите на [страницу релизов](https://github.com/Flowseal/tg-ws-proxy/releases) и скачайте **`TgWsProxy_macos_universal.dmg`** — универсальная сборка для Apple Silicon и Intel. + +1. Открыть образ +2. Перенести **TG WS Proxy.app** в папку **Applications** +3. При первом запуске macOS может попросить подтвердить открытие: **Системные настройки → Конфиденциальность и безопасность → Всё равно открыть** + +### Linux + +Для Debian/Ubuntu скачайте со [страницы релизов](https://github.com/Flowseal/tg-ws-proxy/releases) пакет **`TgWsProxy_linux_amd64.deb`**. + +Для остальных дистрибутивов можно использовать **`TgWsProxy_linux_amd64`** (бинарный файл для x86_64). + +```bash +chmod +x TgWsProxy_linux_amd64 +./TgWsProxy_linux_amd64 +``` + +При первом запуске откроется окно с инструкцией. Приложение работает в системном трее (требуется AppIndicator). + ### Android -Перейдите на [страницу релизов](https://github.com/Flowseal/tg-ws-proxy/releases) и скачайте подписанный APK вида **`tg-ws-proxy-android-v1.2.3.apk`**. + +Перейдите на [страницу релизов](https://github.com/Flowseal/tg-ws-proxy/releases) и скачайте подписанный APK вида **`tg-ws-proxy-android-vX.Y.Z.apk`**. После установки: + - откройте приложение - проверьте `Android background limits` - при необходимости отключите battery optimization и снимите background restrictions @@ -53,25 +78,53 @@ Telegram Desktop → SOCKS5 (127.0.0.1:1080) → TG WS Proxy → WSS (kws*.web.t - нажмите **Open in Telegram** Что важно для стабильной работы на Android: + - разрешите уведомления - отключите battery optimization для приложения ## Установка из исходников +### Консольный proxy + +Для запуска только SOCKS5/WebSocket proxy без tray-интерфейса достаточно базовой установки: + ```bash -pip install -r requirements.txt +pip install -e . +tg-ws-proxy ``` -### Windows (Tray-приложение) +### Windows 10+ ```bash -python windows.py +pip install -e ".[win10]" +tg-ws-proxy-tray-win ``` -### Консольный режим +### Windows 7 ```bash -python proxy/tg_ws_proxy.py [--port PORT] [--dc-ip DC:IP ...] [-v] +pip install -e ".[win7]" +tg-ws-proxy-tray-win +``` + +### macOS + +```bash +pip install -e ".[macos]" +tg-ws-proxy-tray-macos +``` + +### Linux + +```bash +pip install -e ".[linux]" +tg-ws-proxy-tray-linux +``` + +### Консольный режим из исходников + +```bash +tg-ws-proxy [--port PORT] [--host HOST] [--dc-ip DC:IP ...] [-v] ``` ### Android debug APK @@ -117,6 +170,7 @@ android/app/build/outputs/apk/release/app-release.apk | Аргумент | По умолчанию | Описание | |---|---|---| | `--port` | `1080` | Порт SOCKS5-прокси | +| `--host` | `127.0.0.1` | Хост SOCKS5-прокси | | `--dc-ip` | `2:149.154.167.220`, `4:149.154.167.220` | Целевой IP для DC (можно указать несколько раз) | | `-v`, `--verbose` | выкл. | Подробное логирование (DEBUG) | @@ -124,13 +178,27 @@ android/app/build/outputs/apk/release/app-release.apk ```bash # Стандартный запуск -python proxy/tg_ws_proxy.py +tg-ws-proxy # Другой порт и дополнительные DC -python proxy/tg_ws_proxy.py --port 9050 --dc-ip 1:149.154.175.205 --dc-ip 2:149.154.167.220 +tg-ws-proxy --port 9050 --dc-ip 1:149.154.175.205 --dc-ip 2:149.154.167.220 # С подробным логированием -python proxy/tg_ws_proxy.py -v +tg-ws-proxy -v +``` + +## CLI-скрипты (pyproject.toml) + +CLI команды объявляются в `pyproject.toml` в секции `[project.scripts]` и должны указывать на `module:function`. + +Пример: + +```toml +[project.scripts] +tg-ws-proxy = "proxy.tg_ws_proxy:main" +tg-ws-proxy-tray-win = "windows:main" +tg-ws-proxy-tray-macos = "macos:main" +tg-ws-proxy-tray-linux = "linux:main" ``` ## Настройка Telegram Desktop @@ -164,12 +232,17 @@ python proxy/tg_ws_proxy.py -v - **Логин/Пароль:** оставить пустыми Важно: + - сначала должен быть запущен foreground service - если Telegram был уже открыт, иногда проще закрыть и открыть его заново после запуска прокси ## Конфигурация -Tray-приложение хранит данные в `%APPDATA%/TgWsProxy`: +Tray-приложение хранит данные в: + +- **Windows:** `%APPDATA%/TgWsProxy` +- **macOS:** `~/Library/Application Support/TgWsProxy` +- **Linux:** `~/.config/TgWsProxy` (или `$XDG_CONFIG_HOME/TgWsProxy`) ```json { @@ -182,22 +255,17 @@ Tray-приложение хранит данные в `%APPDATA%/TgWsProxy`: } ``` -Android хранит рабочие файлы в приватной директории приложения. Основные параметры редактируются через UI приложения. - ## Автоматическая сборка -Проект содержит спецификацию PyInstaller ([`windows.spec`](packaging/windows.spec)) и GitHub Actions workflow ([`.github/workflows/build.yml`](.github/workflows/build.yml)) для автоматической сборки. +Проект содержит спецификации PyInstaller ([`packaging/windows.spec`](packaging/windows.spec), [`packaging/macos.spec`](packaging/macos.spec), [`packaging/linux.spec`](packaging/linux.spec)) и GitHub Actions workflow ([`.github/workflows/build.yml`](.github/workflows/build.yml)) для автоматической сборки. -Для signed Android release в GitHub Actions нужны secrets: -- `ANDROID_KEYSTORE_BASE64` -- `ANDROID_KEYSTORE_PASSWORD` -- `ANDROID_KEY_ALIAS` -- `ANDROID_KEY_PASSWORD` +Минимально поддерживаемые версии ОС для текущих бинарных сборок: -```bash -pip install pyinstaller -pyinstaller packaging/windows.spec -``` +- Windows 10+ для `TgWsProxy_windows.exe` +- Windows 7 для `TgWsProxy_windows_7.exe` +- Intel macOS 10.15+ +- Apple Silicon macOS 11.0+ +- Linux x86_64 (требуется AppIndicator для системного трея) ## Лицензия diff --git a/linux.py b/linux.py new file mode 100644 index 0000000..9b2ff9e --- /dev/null +++ b/linux.py @@ -0,0 +1,843 @@ +from __future__ import annotations + +import asyncio as _asyncio +import json +import logging +import os +import subprocess +import sys +import threading +import time +from pathlib import Path +from typing import Dict, Optional + +import customtkinter as ctk +import psutil +import pyperclip +import pystray +from PIL import Image, ImageDraw, ImageFont + +import proxy.tg_ws_proxy as tg_ws_proxy + +APP_NAME = "TgWsProxy" +APP_DIR = Path(os.environ.get("XDG_CONFIG_HOME", Path.home() / ".config")) / APP_NAME +CONFIG_FILE = APP_DIR / "config.json" +LOG_FILE = APP_DIR / "proxy.log" +FIRST_RUN_MARKER = APP_DIR / ".first_run_done" +IPV6_WARN_MARKER = APP_DIR / ".ipv6_warned" + + +DEFAULT_CONFIG = { + "port": 1080, + "host": "127.0.0.1", + "dc_ip": ["2:149.154.167.220", "4:149.154.167.220"], + "verbose": False, +} + + +_proxy_thread: Optional[threading.Thread] = None +_async_stop: Optional[object] = None +_tray_icon: Optional[object] = None +_config: dict = {} +_exiting: bool = False +_lock_file_path: Optional[Path] = None + +log = logging.getLogger("tg-ws-tray") + + +def _same_process(lock_meta: dict, proc: psutil.Process) -> bool: + try: + lock_ct = float(lock_meta.get("create_time", 0.0)) + proc_ct = float(proc.create_time()) + if lock_ct > 0 and abs(lock_ct - proc_ct) > 1.0: + return False + except Exception: + return False + + try: + cmdline = proc.cmdline() + for arg in cmdline: + if "linux.py" in arg: + return True + except Exception: + pass + + frozen = bool(getattr(sys, "frozen", False)) + if frozen: + return APP_NAME.lower() in proc.name().lower() + + return False + + +def _release_lock(): + global _lock_file_path + if not _lock_file_path: + return + try: + _lock_file_path.unlink(missing_ok=True) + except Exception: + pass + _lock_file_path = None + + +def _acquire_lock() -> bool: + global _lock_file_path + _ensure_dirs() + lock_files = list(APP_DIR.glob("*.lock")) + + for f in lock_files: + pid = None + meta: dict = {} + + try: + pid = int(f.stem) + except Exception: + f.unlink(missing_ok=True) + continue + + try: + raw = f.read_text(encoding="utf-8").strip() + if raw: + meta = json.loads(raw) + except Exception: + meta = {} + + try: + proc = psutil.Process(pid) + if _same_process(meta, proc): + return False + except Exception: + pass + + f.unlink(missing_ok=True) + + lock_file = APP_DIR / f"{os.getpid()}.lock" + try: + proc = psutil.Process(os.getpid()) + payload = { + "create_time": proc.create_time(), + } + lock_file.write_text(json.dumps(payload, ensure_ascii=False), encoding="utf-8") + except Exception: + lock_file.touch() + + _lock_file_path = lock_file + return True + + +def _ensure_dirs(): + APP_DIR.mkdir(parents=True, exist_ok=True) + + +def load_config() -> dict: + _ensure_dirs() + if CONFIG_FILE.exists(): + try: + with open(CONFIG_FILE, "r", encoding="utf-8") as f: + data = json.load(f) + for k, v in DEFAULT_CONFIG.items(): + data.setdefault(k, v) + return data + except Exception as exc: + log.warning("Failed to load config: %s", exc) + return dict(DEFAULT_CONFIG) + + +def save_config(cfg: dict): + _ensure_dirs() + with open(CONFIG_FILE, "w", encoding="utf-8") as f: + json.dump(cfg, f, indent=2, ensure_ascii=False) + + +def setup_logging(verbose: bool = False): + _ensure_dirs() + root = logging.getLogger() + root.setLevel(logging.DEBUG if verbose else logging.INFO) + + fh = logging.FileHandler(str(LOG_FILE), encoding="utf-8") + fh.setLevel(logging.DEBUG) + fh.setFormatter( + logging.Formatter( + "%(asctime)s %(levelname)-5s %(name)s %(message)s", + datefmt="%Y-%m-%d %H:%M:%S", + ) + ) + root.addHandler(fh) + + if not getattr(sys, "frozen", False): + ch = logging.StreamHandler(sys.stdout) + ch.setLevel(logging.DEBUG if verbose else logging.INFO) + ch.setFormatter( + logging.Formatter( + "%(asctime)s %(levelname)-5s %(message)s", datefmt="%H:%M:%S" + ) + ) + root.addHandler(ch) + + +def _make_icon_image(size: int = 64): + if Image is None: + raise RuntimeError("Pillow is required for tray icon") + img = Image.new("RGBA", (size, size), (0, 0, 0, 0)) + draw = ImageDraw.Draw(img) + + margin = 2 + draw.ellipse( + [margin, margin, size - margin, size - margin], fill=(0, 136, 204, 255) + ) + + try: + font = ImageFont.truetype( + "/usr/share/fonts/truetype/dejavu/DejaVuSans-Bold.ttf", + size=int(size * 0.55), + ) + except Exception: + try: + font = ImageFont.truetype( + "/usr/share/fonts/TTF/DejaVuSans-Bold.ttf", size=int(size * 0.55) + ) + except Exception: + font = ImageFont.load_default() + bbox = draw.textbbox((0, 0), "T", font=font) + tw, th = bbox[2] - bbox[0], bbox[3] - bbox[1] + tx = (size - tw) // 2 - bbox[0] + ty = (size - th) // 2 - bbox[1] + draw.text((tx, ty), "T", fill=(255, 255, 255, 255), font=font) + + return img + + +def _load_icon(): + icon_path = Path(__file__).parent / "icon.ico" + if icon_path.exists() and Image: + try: + return Image.open(str(icon_path)) + except Exception: + pass + return _make_icon_image() + + +def _run_proxy_thread( + port: int, dc_opt: Dict[int, str], verbose: bool, host: str = "127.0.0.1" +): + global _async_stop + loop = _asyncio.new_event_loop() + _asyncio.set_event_loop(loop) + stop_ev = _asyncio.Event() + _async_stop = (loop, stop_ev) + + try: + loop.run_until_complete( + tg_ws_proxy._run(port, dc_opt, stop_event=stop_ev, host=host) + ) + except Exception as exc: + log.error("Proxy thread crashed: %s", exc) + if "Address already in use" in str(exc): + _show_error( + "Не удалось запустить прокси:\nПорт уже используется другим приложением.\n\nЗакройте приложение, использующее этот порт, или измените порт в настройках прокси и перезапустите." + ) + finally: + loop.close() + _async_stop = None + + +def start_proxy(): + global _proxy_thread, _config + if _proxy_thread and _proxy_thread.is_alive(): + log.info("Proxy already running") + return + + cfg = _config + port = cfg.get("port", DEFAULT_CONFIG["port"]) + host = cfg.get("host", DEFAULT_CONFIG["host"]) + dc_ip_list = cfg.get("dc_ip", DEFAULT_CONFIG["dc_ip"]) + verbose = cfg.get("verbose", False) + + try: + dc_opt = tg_ws_proxy.parse_dc_ip_list(dc_ip_list) + except ValueError as e: + log.error("Bad config dc_ip: %s", e) + _show_error(f"Ошибка конфигурации:\n{e}") + return + + log.info("Starting proxy on %s:%d ...", host, port) + _proxy_thread = threading.Thread( + target=_run_proxy_thread, + args=(port, dc_opt, verbose, host), + daemon=True, + name="proxy", + ) + _proxy_thread.start() + + +def stop_proxy(): + global _proxy_thread, _async_stop + if _async_stop: + loop, stop_ev = _async_stop + loop.call_soon_threadsafe(stop_ev.set) + if _proxy_thread: + _proxy_thread.join(timeout=2) + _proxy_thread = None + log.info("Proxy stopped") + + +def restart_proxy(): + log.info("Restarting proxy...") + stop_proxy() + time.sleep(0.3) + start_proxy() + + +def _show_error(text: str, title: str = "TG WS Proxy — Ошибка"): + import tkinter as _tk + from tkinter import messagebox as _mb + + root = _tk.Tk() + root.withdraw() + _mb.showerror(title, text, parent=root) + root.destroy() + + +def _show_info(text: str, title: str = "TG WS Proxy"): + import tkinter as _tk + from tkinter import messagebox as _mb + + root = _tk.Tk() + root.withdraw() + _mb.showinfo(title, text, parent=root) + root.destroy() + + +def _on_open_in_telegram(icon=None, item=None): + port = _config.get("port", DEFAULT_CONFIG["port"]) + url = f"tg://socks?server=127.0.0.1&port={port}" + log.info("Copying %s", url) + + try: + pyperclip.copy(url) + _show_info( + f"Ссылка скопирована в буфер обмена, отправьте её в Telegram и нажмите по ней ЛКМ:\n{url}", + "TG WS Proxy", + ) + except Exception as exc: + log.error("Clipboard copy failed: %s", exc) + _show_error(f"Не удалось скопировать ссылку:\n{exc}") + + +def _on_restart(icon=None, item=None): + threading.Thread(target=restart_proxy, daemon=True).start() + + +def _on_edit_config(icon=None, item=None): + threading.Thread(target=_edit_config_dialog, daemon=True).start() + + +def _edit_config_dialog(): + if ctk is None: + _show_error("customtkinter не установлен.") + return + + cfg = dict(_config) + + ctk.set_appearance_mode("light") + ctk.set_default_color_theme("blue") + + root = ctk.CTk() + root.title("TG WS Proxy — Настройки") + root.resizable(False, False) + root.attributes("-topmost", True) + + icon_img = _load_icon() + if icon_img: + from PIL import ImageTk + + _photo = ImageTk.PhotoImage(icon_img.resize((64, 64))) + root.iconphoto(False, _photo) + + TG_BLUE = "#3390ec" + TG_BLUE_HOVER = "#2b7cd4" + BG = "#ffffff" + FIELD_BG = "#f0f2f5" + FIELD_BORDER = "#d6d9dc" + TEXT_PRIMARY = "#000000" + TEXT_SECONDARY = "#707579" + FONT_FAMILY = "Sans" + + w, h = 420, 480 + sw = root.winfo_screenwidth() + sh = root.winfo_screenheight() + root.geometry(f"{w}x{h}+{(sw - w) // 2}+{(sh - h) // 2}") + root.configure(fg_color=BG) + + frame = ctk.CTkFrame(root, fg_color=BG, corner_radius=0) + frame.pack(fill="both", expand=True, padx=24, pady=20) + + # Host + ctk.CTkLabel( + frame, + text="IP-адрес прокси", + font=(FONT_FAMILY, 13), + text_color=TEXT_PRIMARY, + anchor="w", + ).pack(anchor="w", pady=(0, 4)) + host_var = ctk.StringVar(value=cfg.get("host", "127.0.0.1")) + host_entry = ctk.CTkEntry( + frame, + textvariable=host_var, + width=200, + height=36, + font=(FONT_FAMILY, 13), + corner_radius=10, + fg_color=FIELD_BG, + border_color=FIELD_BORDER, + border_width=1, + text_color=TEXT_PRIMARY, + ) + host_entry.pack(anchor="w", pady=(0, 12)) + + # Port + ctk.CTkLabel( + frame, + text="Порт прокси", + font=(FONT_FAMILY, 13), + text_color=TEXT_PRIMARY, + anchor="w", + ).pack(anchor="w", pady=(0, 4)) + port_var = ctk.StringVar(value=str(cfg.get("port", 1080))) + port_entry = ctk.CTkEntry( + frame, + textvariable=port_var, + width=120, + height=36, + font=(FONT_FAMILY, 13), + corner_radius=10, + fg_color=FIELD_BG, + border_color=FIELD_BORDER, + border_width=1, + text_color=TEXT_PRIMARY, + ) + port_entry.pack(anchor="w", pady=(0, 12)) + + # DC-IP mappings + ctk.CTkLabel( + frame, + text="DC → IP маппинги (по одному на строку, формат DC:IP)", + font=(FONT_FAMILY, 13), + text_color=TEXT_PRIMARY, + anchor="w", + ).pack(anchor="w", pady=(0, 4)) + dc_textbox = ctk.CTkTextbox( + frame, + width=370, + height=120, + font=("Monospace", 12), + corner_radius=10, + fg_color=FIELD_BG, + border_color=FIELD_BORDER, + border_width=1, + text_color=TEXT_PRIMARY, + ) + dc_textbox.pack(anchor="w", pady=(0, 12)) + dc_textbox.insert("1.0", "\n".join(cfg.get("dc_ip", DEFAULT_CONFIG["dc_ip"]))) + + # Verbose + verbose_var = ctk.BooleanVar(value=cfg.get("verbose", False)) + ctk.CTkCheckBox( + frame, + text="Подробное логирование (verbose)", + variable=verbose_var, + font=(FONT_FAMILY, 13), + text_color=TEXT_PRIMARY, + fg_color=TG_BLUE, + hover_color=TG_BLUE_HOVER, + corner_radius=6, + border_width=2, + border_color=FIELD_BORDER, + ).pack(anchor="w", pady=(0, 8)) + + # Info label + ctk.CTkLabel( + frame, + text="Изменения вступят в силу после перезапуска прокси.", + font=(FONT_FAMILY, 11), + text_color=TEXT_SECONDARY, + anchor="w", + ).pack(anchor="w", pady=(0, 16)) + + def on_save(): + import socket as _sock + + host_val = host_var.get().strip() + try: + _sock.inet_aton(host_val) + except OSError: + _show_error("Некорректный IP-адрес.") + return + + try: + port_val = int(port_var.get().strip()) + if not (1 <= port_val <= 65535): + raise ValueError + except ValueError: + _show_error("Порт должен быть числом 1-65535") + return + + lines = [ + l.strip() + for l in dc_textbox.get("1.0", "end").strip().splitlines() + if l.strip() + ] + try: + tg_ws_proxy.parse_dc_ip_list(lines) + except ValueError as e: + _show_error(str(e)) + return + + new_cfg = { + "host": host_val, + "port": port_val, + "dc_ip": lines, + "verbose": verbose_var.get(), + } + save_config(new_cfg) + _config.update(new_cfg) + log.info("Config saved: %s", new_cfg) + + _tray_icon.menu = _build_menu() + + from tkinter import messagebox + + if messagebox.askyesno( + "Перезапустить?", + "Настройки сохранены.\n\nПерезапустить прокси сейчас?", + parent=root, + ): + root.destroy() + restart_proxy() + else: + root.destroy() + + def on_cancel(): + root.destroy() + + btn_frame = ctk.CTkFrame(frame, fg_color="transparent") + btn_frame.pack(fill="x") + ctk.CTkButton( + btn_frame, + text="Сохранить", + width=140, + height=38, + font=(FONT_FAMILY, 14, "bold"), + corner_radius=10, + fg_color=TG_BLUE, + hover_color=TG_BLUE_HOVER, + text_color="#ffffff", + command=on_save, + ).pack(side="left", padx=(0, 10)) + ctk.CTkButton( + btn_frame, + text="Отмена", + width=140, + height=38, + font=(FONT_FAMILY, 14), + corner_radius=10, + fg_color=FIELD_BG, + hover_color=FIELD_BORDER, + text_color=TEXT_PRIMARY, + border_width=1, + border_color=FIELD_BORDER, + command=on_cancel, + ).pack(side="left") + + root.mainloop() + + +def _on_open_logs(icon=None, item=None): + log.info("Opening log file: %s", LOG_FILE) + if LOG_FILE.exists(): + env = os.environ.copy() + env.pop("VIRTUAL_ENV", None) + env.pop("PYTHONPATH", None) + env.pop("PYTHONHOME", None) + + subprocess.Popen( + ["xdg-open", str(LOG_FILE)], + env=env, + stdout=subprocess.DEVNULL, + stderr=subprocess.DEVNULL, + stdin=subprocess.DEVNULL, + start_new_session=True, + ) + else: + _show_info("Файл логов ещё не создан.", "TG WS Proxy") + + +def _on_exit(icon=None, item=None): + global _exiting + if _exiting: + os._exit(0) + return + _exiting = True + log.info("User requested exit") + + def _force_exit(): + time.sleep(3) + os._exit(0) + + threading.Thread(target=_force_exit, daemon=True, name="force-exit").start() + + if icon: + icon.stop() + + +def _show_first_run(): + _ensure_dirs() + if FIRST_RUN_MARKER.exists(): + return + + host = _config.get("host", DEFAULT_CONFIG["host"]) + port = _config.get("port", DEFAULT_CONFIG["port"]) + tg_url = f"tg://socks?server={host}&port={port}" + + if ctk is None: + FIRST_RUN_MARKER.touch() + return + + ctk.set_appearance_mode("light") + ctk.set_default_color_theme("blue") + + TG_BLUE = "#3390ec" + TG_BLUE_HOVER = "#2b7cd4" + BG = "#ffffff" + FIELD_BG = "#f0f2f5" + FIELD_BORDER = "#d6d9dc" + TEXT_PRIMARY = "#000000" + TEXT_SECONDARY = "#707579" + FONT_FAMILY = "Sans" + + root = ctk.CTk() + root.title("TG WS Proxy") + root.resizable(False, False) + root.attributes("-topmost", True) + + icon_img = _load_icon() + if icon_img: + from PIL import ImageTk + + _photo = ImageTk.PhotoImage(icon_img.resize((64, 64))) + root.iconphoto(False, _photo) + + w, h = 520, 440 + sw = root.winfo_screenwidth() + sh = root.winfo_screenheight() + root.geometry(f"{w}x{h}+{(sw - w) // 2}+{(sh - h) // 2}") + root.configure(fg_color=BG) + + frame = ctk.CTkFrame(root, fg_color=BG, corner_radius=0) + frame.pack(fill="both", expand=True, padx=28, pady=24) + + title_frame = ctk.CTkFrame(frame, fg_color="transparent") + title_frame.pack(anchor="w", pady=(0, 16), fill="x") + + # Blue accent bar + accent_bar = ctk.CTkFrame( + title_frame, fg_color=TG_BLUE, width=4, height=32, corner_radius=2 + ) + accent_bar.pack(side="left", padx=(0, 12)) + + ctk.CTkLabel( + title_frame, + text="Прокси запущен и работает в системном трее", + font=(FONT_FAMILY, 17, "bold"), + text_color=TEXT_PRIMARY, + ).pack(side="left") + + # Info sections + sections = [ + ("Как подключить Telegram Desktop:", True), + (" Автоматически:", True), + (f" ПКМ по иконке в трее → «Открыть в Telegram»", False), + (f" Или ссылка: {tg_url}", False), + ("\n Вручную:", True), + (" Настройки → Продвинутые → Тип подключения → Прокси", False), + (f" SOCKS5 → {host} : {port} (без логина/пароля)", False), + ] + + for text, bold in sections: + weight = "bold" if bold else "normal" + ctk.CTkLabel( + frame, + text=text, + font=(FONT_FAMILY, 13, weight), + text_color=TEXT_PRIMARY, + anchor="w", + justify="left", + ).pack(anchor="w", pady=1) + + # Spacer + ctk.CTkFrame(frame, fg_color="transparent", height=16).pack() + + # Separator + ctk.CTkFrame(frame, fg_color=FIELD_BORDER, height=1, corner_radius=0).pack( + fill="x", pady=(0, 12) + ) + + # Checkbox + auto_var = ctk.BooleanVar(value=True) + ctk.CTkCheckBox( + frame, + text="Открыть прокси в Telegram сейчас", + variable=auto_var, + font=(FONT_FAMILY, 13), + text_color=TEXT_PRIMARY, + fg_color=TG_BLUE, + hover_color=TG_BLUE_HOVER, + corner_radius=6, + border_width=2, + border_color=FIELD_BORDER, + ).pack(anchor="w", pady=(0, 16)) + + def on_ok(): + FIRST_RUN_MARKER.touch() + open_tg = auto_var.get() + root.destroy() + if open_tg: + _on_open_in_telegram() + + ctk.CTkButton( + frame, + text="Начать", + width=180, + height=42, + font=(FONT_FAMILY, 15, "bold"), + corner_radius=10, + fg_color=TG_BLUE, + hover_color=TG_BLUE_HOVER, + text_color="#ffffff", + command=on_ok, + ).pack(pady=(0, 0)) + + root.protocol("WM_DELETE_WINDOW", on_ok) + root.mainloop() + + +def _has_ipv6_enabled() -> bool: + import socket as _sock + + try: + addrs = _sock.getaddrinfo(_sock.gethostname(), None, _sock.AF_INET6) + for addr in addrs: + ip = addr[4][0] + if ip and not ip.startswith("::1") and not ip.startswith("fe80::1"): + return True + except Exception: + pass + try: + s = _sock.socket(_sock.AF_INET6, _sock.SOCK_STREAM) + s.bind(("::1", 0)) + s.close() + return True + except Exception: + return False + + +def _check_ipv6_warning(): + _ensure_dirs() + if IPV6_WARN_MARKER.exists(): + return + if not _has_ipv6_enabled(): + return + + IPV6_WARN_MARKER.touch() + + threading.Thread(target=_show_ipv6_dialog, daemon=True).start() + + +def _show_ipv6_dialog(): + _show_info( + "На вашем компьютере включена поддержка подключения по IPv6.\n\n" + "Telegram может пытаться подключаться через IPv6, " + "что не поддерживается и может привести к ошибкам.\n\n" + "Если прокси не работает или в логах присутствуют ошибки, " + "связанные с попытками подключения по IPv6 - " + "попробуйте отключить в настройках прокси Telegram попытку соединения " + "по IPv6. Если данная мера не помогает, попробуйте отключить IPv6 " + "в системе.\n\n" + "Это предупреждение будет показано только один раз.", + "TG WS Proxy", + ) + + +def _build_menu(): + if pystray is None: + return None + host = _config.get("host", DEFAULT_CONFIG["host"]) + port = _config.get("port", DEFAULT_CONFIG["port"]) + return pystray.Menu( + pystray.MenuItem( + f"Открыть в Telegram ({host}:{port})", _on_open_in_telegram, default=True + ), + pystray.Menu.SEPARATOR, + pystray.MenuItem("Перезапустить прокси", _on_restart), + pystray.MenuItem("Настройки...", _on_edit_config), + pystray.MenuItem("Открыть логи", _on_open_logs), + pystray.Menu.SEPARATOR, + pystray.MenuItem("Выход", _on_exit), + ) + + +def run_tray(): + global _tray_icon, _config + + _config = load_config() + save_config(_config) + + if LOG_FILE.exists(): + try: + LOG_FILE.unlink() + except Exception: + pass + + setup_logging(_config.get("verbose", False)) + log.info("TG WS Proxy tray app starting") + log.info("Config: %s", _config) + log.info("Log file: %s", LOG_FILE) + + if pystray is None or Image is None: + log.error("pystray or Pillow not installed; running in console mode") + start_proxy() + try: + while True: + time.sleep(1) + except KeyboardInterrupt: + stop_proxy() + return + + start_proxy() + + _show_first_run() + _check_ipv6_warning() + + icon_image = _load_icon() + _tray_icon = pystray.Icon(APP_NAME, icon_image, "TG WS Proxy", menu=_build_menu()) + + log.info("Tray icon running") + _tray_icon.run() + + stop_proxy() + log.info("Tray app exited") + + +def main(): + if not _acquire_lock(): + _show_info("Приложение уже запущено.", os.path.basename(sys.argv[0])) + return + + try: + run_tray() + finally: + _release_lock() + + +if __name__ == "__main__": + main() diff --git a/macos.py b/macos.py new file mode 100644 index 0000000..e1806cf --- /dev/null +++ b/macos.py @@ -0,0 +1,623 @@ +from __future__ import annotations + +import json +import logging +import os +import psutil +import subprocess +import sys +import threading +import time +import webbrowser +import asyncio as _asyncio +from pathlib import Path +from typing import Dict, Optional + +try: + import rumps +except ImportError: + rumps = None + +try: + from PIL import Image, ImageDraw, ImageFont +except ImportError: + Image = ImageDraw = ImageFont = None + +try: + import pyperclip +except ImportError: + pyperclip = None + +import proxy.tg_ws_proxy as tg_ws_proxy + +APP_NAME = "TgWsProxy" +APP_DIR = Path.home() / "Library" / "Application Support" / APP_NAME +CONFIG_FILE = APP_DIR / "config.json" +LOG_FILE = APP_DIR / "proxy.log" +FIRST_RUN_MARKER = APP_DIR / ".first_run_done" +IPV6_WARN_MARKER = APP_DIR / ".ipv6_warned" +MENUBAR_ICON_PATH = APP_DIR / "menubar_icon.png" + +DEFAULT_CONFIG = { + "port": 1080, + "host": "127.0.0.1", + "dc_ip": ["2:149.154.167.220", "4:149.154.167.220"], + "verbose": False, +} + +_proxy_thread: Optional[threading.Thread] = None +_async_stop: Optional[object] = None +_app: Optional[object] = None +_config: dict = {} +_exiting: bool = False +_lock_file_path: Optional[Path] = None + +log = logging.getLogger("tg-ws-tray") + + +# Single-instance lock + +def _same_process(lock_meta: dict, proc: psutil.Process) -> bool: + try: + lock_ct = float(lock_meta.get("create_time", 0.0)) + proc_ct = float(proc.create_time()) + if lock_ct > 0 and abs(lock_ct - proc_ct) > 1.0: + return False + except Exception: + return False + + frozen = bool(getattr(sys, "frozen", False)) + if frozen: + return APP_NAME.lower() in proc.name().lower() + return False + + +def _release_lock(): + global _lock_file_path + if not _lock_file_path: + return + try: + _lock_file_path.unlink(missing_ok=True) + except Exception: + pass + _lock_file_path = None + + +def _acquire_lock() -> bool: + global _lock_file_path + _ensure_dirs() + lock_files = list(APP_DIR.glob("*.lock")) + + for f in lock_files: + pid = None + meta: dict = {} + + try: + pid = int(f.stem) + except Exception: + f.unlink(missing_ok=True) + continue + + try: + raw = f.read_text(encoding="utf-8").strip() + if raw: + meta = json.loads(raw) + except Exception: + meta = {} + + try: + proc = psutil.Process(pid) + if _same_process(meta, proc): + return False + except Exception: + pass + + f.unlink(missing_ok=True) + + lock_file = APP_DIR / f"{os.getpid()}.lock" + try: + proc = psutil.Process(os.getpid()) + payload = {"create_time": proc.create_time()} + lock_file.write_text(json.dumps(payload, ensure_ascii=False), + encoding="utf-8") + except Exception: + lock_file.touch() + + _lock_file_path = lock_file + return True + + +# Filesystem helpers + +def _ensure_dirs(): + APP_DIR.mkdir(parents=True, exist_ok=True) + + +def load_config() -> dict: + _ensure_dirs() + if CONFIG_FILE.exists(): + try: + with open(CONFIG_FILE, "r", encoding="utf-8") as f: + data = json.load(f) + for k, v in DEFAULT_CONFIG.items(): + data.setdefault(k, v) + return data + except Exception as exc: + log.warning("Failed to load config: %s", exc) + return dict(DEFAULT_CONFIG) + + +def save_config(cfg: dict): + _ensure_dirs() + with open(CONFIG_FILE, "w", encoding="utf-8") as f: + json.dump(cfg, f, indent=2, ensure_ascii=False) + + +def setup_logging(verbose: bool = False): + _ensure_dirs() + root = logging.getLogger() + root.setLevel(logging.DEBUG if verbose else logging.INFO) + + fh = logging.FileHandler(str(LOG_FILE), encoding="utf-8") + fh.setLevel(logging.DEBUG) + fh.setFormatter(logging.Formatter( + "%(asctime)s %(levelname)-5s %(name)s %(message)s", + datefmt="%Y-%m-%d %H:%M:%S")) + root.addHandler(fh) + + if not getattr(sys, "frozen", False): + ch = logging.StreamHandler(sys.stdout) + ch.setLevel(logging.DEBUG if verbose else logging.INFO) + ch.setFormatter(logging.Formatter( + "%(asctime)s %(levelname)-5s %(message)s", + datefmt="%H:%M:%S")) + root.addHandler(ch) + + +# Menubar icon + +def _make_menubar_icon(size: int = 44): + if Image is None: + return None + img = Image.new("RGBA", (size, size), (0, 0, 0, 0)) + draw = ImageDraw.Draw(img) + + margin = size // 11 + draw.ellipse([margin, margin, size - margin, size - margin], + fill=(0, 0, 0, 255)) + + try: + font = ImageFont.truetype( + "/System/Library/Fonts/Helvetica.ttc", + size=int(size * 0.55)) + except Exception: + font = ImageFont.load_default() + + bbox = draw.textbbox((0, 0), "T", font=font) + tw, th = bbox[2] - bbox[0], bbox[3] - bbox[1] + tx = (size - tw) // 2 - bbox[0] + ty = (size - th) // 2 - bbox[1] + draw.text((tx, ty), "T", fill=(255, 255, 255, 255), font=font) + return img + +# Generate menubar icon PNG if it does not exist. +def _ensure_menubar_icon(): + if MENUBAR_ICON_PATH.exists(): + return + _ensure_dirs() + img = _make_menubar_icon(44) + if img: + img.save(str(MENUBAR_ICON_PATH), "PNG") + + +# Native macOS dialogs + +def _osascript(script: str) -> str: + r = subprocess.run( + ['osascript', '-e', script], + capture_output=True, text=True) + return r.stdout.strip() + + +def _show_error(text: str, title: str = "TG WS Proxy"): + text_esc = text.replace('\\', '\\\\').replace('"', '\\"') + title_esc = title.replace('\\', '\\\\').replace('"', '\\"') + _osascript( + f'display dialog "{text_esc}" with title "{title_esc}" ' + f'buttons {{"OK"}} default button "OK" with icon stop') + + +def _show_info(text: str, title: str = "TG WS Proxy"): + text_esc = text.replace('\\', '\\\\').replace('"', '\\"') + title_esc = title.replace('\\', '\\\\').replace('"', '\\"') + _osascript( + f'display dialog "{text_esc}" with title "{title_esc}" ' + f'buttons {{"OK"}} default button "OK" with icon note') + + +def _ask_yes_no(text: str, title: str = "TG WS Proxy") -> bool: + text_esc = text.replace('\\', '\\\\').replace('"', '\\"') + title_esc = title.replace('\\', '\\\\').replace('"', '\\"') + result = _osascript( + f'display dialog "{text_esc}" with title "{title_esc}" ' + f'buttons {{"Нет", "Да"}} default button "Да" with icon note') + return "Да" in result + + +# Proxy lifecycle + +def _run_proxy_thread(port: int, dc_opt: Dict[int, str], verbose: bool, + host: str = '127.0.0.1'): + global _async_stop + loop = _asyncio.new_event_loop() + _asyncio.set_event_loop(loop) + stop_ev = _asyncio.Event() + _async_stop = (loop, stop_ev) + + try: + loop.run_until_complete( + tg_ws_proxy._run(port, dc_opt, stop_event=stop_ev, host=host)) + except Exception as exc: + log.error("Proxy thread crashed: %s", exc) + if "Address already in use" in str(exc): + _show_error( + "Не удалось запустить прокси:\n" + "Порт уже используется другим приложением.\n\n" + "Закройте приложение, использующее этот порт, " + "или измените порт в настройках прокси и перезапустите.") + finally: + loop.close() + _async_stop = None + + +def start_proxy(): + global _proxy_thread, _config + if _proxy_thread and _proxy_thread.is_alive(): + log.info("Proxy already running") + return + + cfg = _config + port = cfg.get("port", DEFAULT_CONFIG["port"]) + host = cfg.get("host", DEFAULT_CONFIG["host"]) + dc_ip_list = cfg.get("dc_ip", DEFAULT_CONFIG["dc_ip"]) + verbose = cfg.get("verbose", False) + + try: + dc_opt = tg_ws_proxy.parse_dc_ip_list(dc_ip_list) + except ValueError as e: + log.error("Bad config dc_ip: %s", e) + _show_error(f"Ошибка конфигурации:\n{e}") + return + + log.info("Starting proxy on %s:%d ...", host, port) + _proxy_thread = threading.Thread( + target=_run_proxy_thread, + args=(port, dc_opt, verbose, host), + daemon=True, name="proxy") + _proxy_thread.start() + + +def stop_proxy(): + global _proxy_thread, _async_stop + if _async_stop: + loop, stop_ev = _async_stop + loop.call_soon_threadsafe(stop_ev.set) + if _proxy_thread: + _proxy_thread.join(timeout=2) + _proxy_thread = None + log.info("Proxy stopped") + + +def restart_proxy(): + log.info("Restarting proxy...") + stop_proxy() + time.sleep(0.3) + start_proxy() + + +# Menu callbacks + +def _on_open_in_telegram(_=None): + port = _config.get("port", DEFAULT_CONFIG["port"]) + url = f"tg://socks?server=127.0.0.1&port={port}" + log.info("Opening %s", url) + try: + result = subprocess.call(['open', url]) + if result != 0: + raise RuntimeError("open command failed") + except Exception: + log.info("open command failed, trying webbrowser") + try: + if not webbrowser.open(url): + raise RuntimeError("webbrowser.open returned False") + except Exception: + log.info("Browser open failed, copying to clipboard") + try: + if pyperclip: + pyperclip.copy(url) + else: + subprocess.run(['pbcopy'], input=url.encode(), + check=True) + _show_info( + "Не удалось открыть Telegram автоматически.\n\n" + f"Ссылка скопирована в буфер обмена:\n{url}") + except Exception as exc: + log.error("Clipboard copy failed: %s", exc) + _show_error(f"Не удалось скопировать ссылку:\n{exc}") + + +def _on_restart(_=None): + def _do_restart(): + global _config + _config = load_config() + if _app: + _app.update_menu_title() + restart_proxy() + + threading.Thread(target=_do_restart, daemon=True).start() + + +def _on_open_logs(_=None): + log.info("Opening log file: %s", LOG_FILE) + if LOG_FILE.exists(): + subprocess.call(['open', str(LOG_FILE)]) + else: + _show_info("Файл логов ещё не создан.") + +# Show a native text input dialog. Returns None if cancelled. +def _osascript_input(prompt: str, default: str, + title: str = "TG WS Proxy") -> Optional[str]: + prompt_esc = prompt.replace('\\', '\\\\').replace('"', '\\"') + default_esc = default.replace('\\', '\\\\').replace('"', '\\"') + title_esc = title.replace('\\', '\\\\').replace('"', '\\"') + r = subprocess.run( + ['osascript', '-e', + f'text returned of (display dialog "{prompt_esc}" ' + f'default answer "{default_esc}" ' + f'with title "{title_esc}" ' + f'buttons {{"Отмена", "OK"}} default button "OK")'], + capture_output=True, text=True) + if r.returncode != 0: + return None + return r.stdout.rstrip("\r\n") + + +def _on_edit_config(_=None): + threading.Thread(target=_edit_config_dialog, daemon=True).start() + + +# Settings via native macOS dialogs +def _edit_config_dialog(): + cfg = load_config() + + # Host + host = _osascript_input( + "IP-адрес прокси:", + cfg.get("host", DEFAULT_CONFIG["host"])) + if host is None: + return + host = host.strip() + + import socket as _sock + try: + _sock.inet_aton(host) + except OSError: + _show_error("Некорректный IP-адрес.") + return + + # Port + port_str = _osascript_input( + "Порт прокси:", + str(cfg.get("port", DEFAULT_CONFIG["port"]))) + if port_str is None: + return + try: + port = int(port_str.strip()) + if not (1 <= port <= 65535): + raise ValueError + except ValueError: + _show_error("Порт должен быть числом 1-65535") + return + + # DC-IP mappings + dc_default = ", ".join(cfg.get("dc_ip", DEFAULT_CONFIG["dc_ip"])) + dc_str = _osascript_input( + "DC → IP маппинги (через запятую, формат DC:IP):\n" + "Например: 2:149.154.167.220, 4:149.154.167.220", + dc_default) + if dc_str is None: + return + dc_lines = [s.strip() for s in dc_str.replace(',', '\n').splitlines() + if s.strip()] + try: + tg_ws_proxy.parse_dc_ip_list(dc_lines) + except ValueError as e: + _show_error(str(e)) + return + + # Verbose + verbose = _ask_yes_no("Включить подробное логирование (verbose)?") + + new_cfg = { + "host": host, + "port": port, + "dc_ip": dc_lines, + "verbose": verbose, + } + save_config(new_cfg) + log.info("Config saved: %s", new_cfg) + + global _config + _config = new_cfg + if _app: + _app.update_menu_title() + + if _ask_yes_no("Настройки сохранены.\n\nПерезапустить прокси сейчас?"): + restart_proxy() + + +# First-run & IPv6 dialogs + +def _show_first_run(): + _ensure_dirs() + if FIRST_RUN_MARKER.exists(): + return + + host = _config.get("host", DEFAULT_CONFIG["host"]) + port = _config.get("port", DEFAULT_CONFIG["port"]) + tg_url = f"tg://socks?server={host}&port={port}" + + text = ( + f"Прокси запущен и работает в строке меню.\n\n" + f"Как подключить Telegram Desktop:\n\n" + f"Автоматически:\n" + f" Нажмите «Открыть в Telegram» в меню\n" + f" Или ссылка: {tg_url}\n\n" + f"Вручную:\n" + f" Настройки → Продвинутые → Тип подключения → Прокси\n" + f" SOCKS5 → {host} : {port} (без логина/пароля)\n\n" + f"Открыть прокси в Telegram сейчас?" + ) + + FIRST_RUN_MARKER.touch() + + if _ask_yes_no(text, "TG WS Proxy"): + _on_open_in_telegram() + + +def _has_ipv6_enabled() -> bool: + import socket as _sock + try: + addrs = _sock.getaddrinfo(_sock.gethostname(), None, _sock.AF_INET6) + for addr in addrs: + ip = addr[4][0] + if ip and not ip.startswith('::1') and not ip.startswith('fe80::1'): + return True + except Exception: + pass + try: + s = _sock.socket(_sock.AF_INET6, _sock.SOCK_STREAM) + s.bind(('::1', 0)) + s.close() + return True + except Exception: + return False + + +def _check_ipv6_warning(): + _ensure_dirs() + if IPV6_WARN_MARKER.exists(): + return + if not _has_ipv6_enabled(): + return + + IPV6_WARN_MARKER.touch() + + _show_info( + "На вашем компьютере включена поддержка подключения по IPv6.\n\n" + "Telegram может пытаться подключаться через IPv6, " + "что не поддерживается и может привести к ошибкам.\n\n" + "Если прокси не работает, попробуйте отключить " + "попытку соединения по IPv6 в настройках прокси Telegram.\n\n" + "Это предупреждение будет показано только один раз.") + + +# rumps menubar app + +_TgWsProxyAppBase = rumps.App if rumps else object + + +class TgWsProxyApp(_TgWsProxyAppBase): + def __init__(self): + _ensure_menubar_icon() + icon_path = (str(MENUBAR_ICON_PATH) + if MENUBAR_ICON_PATH.exists() else None) + + host = _config.get("host", DEFAULT_CONFIG["host"]) + port = _config.get("port", DEFAULT_CONFIG["port"]) + + self._open_tg_item = rumps.MenuItem( + f"Открыть в Telegram ({host}:{port})", + callback=_on_open_in_telegram) + self._restart_item = rumps.MenuItem( + "Перезапустить прокси", + callback=_on_restart) + self._settings_item = rumps.MenuItem( + "Настройки...", + callback=_on_edit_config) + self._logs_item = rumps.MenuItem( + "Открыть логи", + callback=_on_open_logs) + + super().__init__( + "TG WS Proxy", + icon=icon_path, + template=False, + quit_button="Выход", + menu=[ + self._open_tg_item, + None, + self._restart_item, + self._settings_item, + self._logs_item, + ]) + + def update_menu_title(self): + host = _config.get("host", DEFAULT_CONFIG["host"]) + port = _config.get("port", DEFAULT_CONFIG["port"]) + self._open_tg_item.title = ( + f"Открыть в Telegram ({host}:{port})") + + +def run_menubar(): + global _app, _config + + _config = load_config() + save_config(_config) + + if LOG_FILE.exists(): + try: + LOG_FILE.unlink() + except Exception: + pass + + setup_logging(_config.get("verbose", False)) + log.info("TG WS Proxy menubar app starting") + log.info("Config: %s", _config) + log.info("Log file: %s", LOG_FILE) + + if rumps is None or Image is None: + log.error("rumps or Pillow not installed; running in console mode") + start_proxy() + try: + while True: + time.sleep(1) + except KeyboardInterrupt: + stop_proxy() + return + + start_proxy() + _show_first_run() + _check_ipv6_warning() + + _app = TgWsProxyApp() + log.info("Menubar app running") + _app.run() + + stop_proxy() + log.info("Menubar app exited") + + +def main(): + if not _acquire_lock(): + _show_info("Приложение уже запущено.") + return + + try: + run_menubar() + finally: + _release_lock() + + +if __name__ == "__main__": + main() diff --git a/packaging/linux.spec b/packaging/linux.spec new file mode 100644 index 0000000..ab27315 --- /dev/null +++ b/packaging/linux.spec @@ -0,0 +1,80 @@ +# -*- mode: python ; coding: utf-8 -*- + +import sys +import os +import glob + +from PyInstaller.utils.hooks import collect_submodules, collect_data_files + +block_cipher = None + +# customtkinter ships JSON themes + assets that must be bundled +import customtkinter +ctk_path = os.path.dirname(customtkinter.__file__) + +# Collect gi (PyGObject) submodules and data so pystray._appindicator works +gi_hiddenimports = collect_submodules('gi') +gi_datas = collect_data_files('gi') + +# Collect GObject typelib files from the system +typelib_dirs = glob.glob('/usr/lib/*/girepository-1.0') +typelib_datas = [] +for d in typelib_dirs: + typelib_datas.append((d, 'gi_typelibs')) + +a = Analysis( + [os.path.join(os.path.dirname(SPEC), os.pardir, 'linux.py')], + pathex=[], + binaries=[], + datas=[(ctk_path, 'customtkinter/')] + gi_datas + typelib_datas, + hiddenimports=[ + 'pystray._appindicator', + 'PIL._tkinter_finder', + 'customtkinter', + 'cryptography.hazmat.primitives.ciphers', + 'cryptography.hazmat.primitives.ciphers.algorithms', + 'cryptography.hazmat.primitives.ciphers.modes', + 'cryptography.hazmat.backends.openssl', + 'gi', + '_gi', + 'gi.repository.GLib', + 'gi.repository.GObject', + 'gi.repository.Gtk', + 'gi.repository.Gdk', + 'gi.repository.AyatanaAppIndicator3', + ] + gi_hiddenimports, + hookspath=[], + hooksconfig={}, + runtime_hooks=[], + excludes=[], + noarchive=False, + cipher=block_cipher, +) + +icon_path = os.path.join(os.path.dirname(SPEC), os.pardir, 'icon.ico') +if os.path.exists(icon_path): + a.datas += [('icon.ico', icon_path, 'DATA')] + +pyz = PYZ(a.pure, a.zipped_data, cipher=block_cipher) + +exe = EXE( + pyz, + a.scripts, + a.binaries, + a.zipfiles, + a.datas, + [], + name='TgWsProxy', + debug=False, + bootloader_ignore_signals=False, + strip=True, + upx=True, + upx_exclude=[], + runtime_tmpdir=None, + console=False, + disable_windowed_traceback=False, + argv_emulation=False, + target_arch=None, + codesign_identity=None, + entitlements_file=None, +) diff --git a/packaging/macos.spec b/packaging/macos.spec new file mode 100644 index 0000000..5f38945 --- /dev/null +++ b/packaging/macos.spec @@ -0,0 +1,83 @@ +# -*- mode: python ; coding: utf-8 -*- + +import sys +import os + +block_cipher = None + +a = Analysis( + [os.path.join(os.path.dirname(SPEC), os.pardir, 'macos.py')], + pathex=[], + binaries=[], + datas=[], + hiddenimports=[ + 'rumps', + 'objc', + 'Foundation', + 'AppKit', + 'PyObjCTools', + 'PyObjCTools.AppHelper', + 'cryptography.hazmat.primitives.ciphers', + 'cryptography.hazmat.primitives.ciphers.algorithms', + 'cryptography.hazmat.primitives.ciphers.modes', + 'cryptography.hazmat.backends.openssl', + ], + hookspath=[], + hooksconfig={}, + runtime_hooks=[], + excludes=[], + noarchive=False, + cipher=block_cipher, +) + +icon_path = os.path.join(os.path.dirname(SPEC), os.pardir, 'icon.icns') +if not os.path.exists(icon_path): + icon_path = None + +pyz = PYZ(a.pure, a.zipped_data, cipher=block_cipher) + +exe = EXE( + pyz, + a.scripts, + [], + exclude_binaries=True, + name='TgWsProxy', + debug=False, + bootloader_ignore_signals=False, + strip=False, + upx=False, + console=False, + argv_emulation=False, + target_arch='universal2', + codesign_identity=None, + entitlements_file=None, +) + +coll = COLLECT( + exe, + a.binaries, + a.zipfiles, + a.datas, + strip=False, + upx=False, + upx_exclude=[], + name='TgWsProxy', +) + +app = BUNDLE( + coll, + name='TG WS Proxy.app', + icon=icon_path, + bundle_identifier='com.tgwsproxy.app', + info_plist={ + 'CFBundleName': 'TG WS Proxy', + 'CFBundleDisplayName': 'TG WS Proxy', + 'CFBundleShortVersionString': '1.0.0', + 'CFBundleVersion': '1.0.0', + 'LSMinimumSystemVersion': '10.15', + 'LSUIElement': True, + 'NSHighResolutionCapable': True, + 'NSAppleEventsUsageDescription': + 'TG WS Proxy needs to display dialogs.', + }, +) diff --git a/proxy/__init__.py b/proxy/__init__.py index 868f333..f74f503 100644 --- a/proxy/__init__.py +++ b/proxy/__init__.py @@ -1 +1 @@ -"""TG WS Proxy core package.""" +__version__ = "1.1.3" \ No newline at end of file diff --git a/proxy/tg_ws_proxy.py b/proxy/tg_ws_proxy.py index b70b483..8d9b276 100644 --- a/proxy/tg_ws_proxy.py +++ b/proxy/tg_ws_proxy.py @@ -19,8 +19,8 @@ DEFAULT_PORT = 1080 log = logging.getLogger('tg-ws-proxy') _TCP_NODELAY = True -_RECV_BUF = 65536 -_SEND_BUF = 65536 +_RECV_BUF = 256 * 1024 +_SEND_BUF = 256 * 1024 _WS_POOL_SIZE = 4 _WS_POOL_MAX_AGE = 120.0 @@ -65,6 +65,13 @@ _IP_TO_DC: Dict[str, Tuple[int, bool]] = { '149.154.171.5': (5, False), '91.108.56.102': (5, True), '91.108.56.128': (5, True), '91.108.56.151': (5, True), + # DC203 + '91.105.192.100': (203, False), +} + +# This case might work but not actually sure +_DC_OVERRIDES: Dict[int, int] = { + 203: 2 } _dc_opt: Dict[int, Optional[str]] = {} @@ -76,7 +83,8 @@ _ws_blacklist: Set[Tuple[int, bool]] = set() # Rate-limit re-attempts per (dc, is_media) _dc_fail_until: Dict[Tuple[int, bool], float] = {} -_DC_FAIL_COOLDOWN = 60.0 # seconds +_DC_FAIL_COOLDOWN = 30.0 # seconds to keep reduced WS timeout after failure +_WS_FAIL_TIMEOUT = 2.0 # quick-retry timeout after a recent WS failure _ssl_ctx = ssl.create_default_context() @@ -375,7 +383,7 @@ def _dc_from_init(data: bytes) -> Tuple[Optional[int], bool]: proto, dc_raw, plain.hex()) if proto in (0xEFEFEFEF, 0xEEEEEEEE, 0xDDDDDDDD): dc = abs(dc_raw) - if 1 <= dc <= 5: + if 1 <= dc <= 5 or dc == 203: return dc, (dc_raw < 0) except Exception as exc: log.debug("DC extraction failed: %s", exc) @@ -460,6 +468,7 @@ class _MsgSplitter: def _ws_domains(dc: int, is_media) -> List[str]: + dc = _DC_OVERRIDES.get(dc, dc) if is_media is None or is_media: return [f'kws{dc}-1.web.telegram.org', f'kws{dc}.web.telegram.org'] return [f'kws{dc}.web.telegram.org', f'kws{dc}-1.web.telegram.org'] @@ -915,20 +924,10 @@ async def _handle_client(reader, writer): label, dc, media_tag) return - # -- Cooldown check -- - fail_until = _dc_fail_until.get(dc_key, 0) - if now < fail_until: - remaining = fail_until - now - log.debug("[%s] DC%d%s WS cooldown (%.0fs) -> TCP", - label, dc, media_tag, remaining) - ok = await _tcp_fallback(reader, writer, dst, port, init, - label, dc=dc, is_media=is_media) - if ok: - log.info("[%s] DC%d%s TCP fallback closed", - label, dc, media_tag) - return - # -- Try WebSocket via direct connection -- + fail_until = _dc_fail_until.get(dc_key, 0) + ws_timeout = _WS_FAIL_TIMEOUT if now < fail_until else 10.0 + domains = _ws_domains(dc, is_media) target = _dc_opt[dc] ws = None @@ -946,7 +945,7 @@ async def _handle_client(reader, writer): label, dc, media_tag, dst, port, url, target) try: ws = await RawWebSocket.connect(target, domain, - timeout=10) + timeout=ws_timeout) all_redirects = False break except WsHandshakeError as exc: @@ -1131,13 +1130,16 @@ def main(): ap.add_argument('--host', type=str, default='127.0.0.1', help='Listen host (default 127.0.0.1)') ap.add_argument('--dc-ip', metavar='DC:IP', action='append', - default=['2:149.154.167.220', '4:149.154.167.220'], + default=[], help='Target IP for a DC, e.g. --dc-ip 1:149.154.175.205' ' --dc-ip 2:149.154.167.220') ap.add_argument('-v', '--verbose', action='store_true', help='Debug logging') args = ap.parse_args() + if not args.dc_ip: + args.dc_ip = ['2:149.154.167.220', '4:149.154.167.220'] + try: dc_opt = parse_dc_ip_list(args.dc_ip) except ValueError as e: diff --git a/pyproject.toml b/pyproject.toml new file mode 100644 index 0000000..bbd9c1a --- /dev/null +++ b/pyproject.toml @@ -0,0 +1,95 @@ +[build-system] +requires = ["hatchling>=1.25.0"] +build-backend = "hatchling.build" + +[project] +name = "tg-ws-proxy" +dynamic=["version"] + +description = "Telegram Desktop WebSocket Bridge Proxy" +readme = "README.md" +requires-python = ">=3.8" + +license = { name = "MIT", file = "LICENSE" } + +authors = [ + { name = "Flowseal" } +] + +keywords = [ + "telegram", + "proxy", + "websocket" +] +classifiers = [ + "Development Status :: 5 - Production/Stable", + "Environment :: Console", + "Environment :: MacOS X :: Cocoa", + "Environment :: Win32 (MS Windows)", + "Environment :: X11 Applications :: GTK", + "Intended Audience :: Customer Service", + "Programming Language :: Python :: 3", + "License :: OSI Approved :: MIT License", + "Operating System :: MacOS :: MacOS X", + "Operating System :: Microsoft :: Windows", + "Operating System :: POSIX :: Linux", + "Topic :: System :: Networking :: Firewalls", +] + +dependencies = [ + "cryptography==41.0.7; platform_system == 'Windows' and python_version < '3.9'", + "cryptography==46.0.5; platform_system != 'Windows' or python_version >= '3.9'", +] + +[project.optional-dependencies] +win7 = [ + "customtkinter==5.2.2", + "Pillow==10.4.0", + "psutil==5.9.8", + "pystray==0.19.5", + "pyperclip==1.9.0", +] + +win10 = [ + "customtkinter==5.2.2", + "Pillow==12.1.1", + "psutil==7.0.0", + "pystray==0.19.5", + "pyperclip==1.9.0", +] + +macos = [ + "Pillow==12.1.0", + "psutil==7.0.0", + "pyperclip==1.9.0", + "rumps==0.4.0", +] + +linux = [ + "customtkinter==5.2.2", + "Pillow==12.1.1", + "psutil==7.0.0", + "pystray==0.19.5", + "pyperclip==1.9.0", +] + +[project.scripts] +tg-ws-proxy = "proxy.tg_ws_proxy:main" +tg-ws-proxy-tray-win = "windows:main" +tg-ws-proxy-tray-macos = "macos:main" +tg-ws-proxy-tray-linux = "linux:main" + +[project.urls] +Source = "https://github.com/Flowseal/tg-ws-proxy" +Issues = "https://github.com/Flowseal/tg-ws-proxy/issues" + +[tool.hatch.build.targets.wheel] +packages = ["proxy"] + +[tool.hatch.build.force-include] +"windows.py" = "windows.py" +"macos.py" = "macos.py" +"linux.py" = "linux.py" + +[tool.hatch.version] +path = "proxy/__init__.py" diff --git a/requirements-win7.txt b/requirements-win7.txt deleted file mode 100644 index 41a8174..0000000 --- a/requirements-win7.txt +++ /dev/null @@ -1,6 +0,0 @@ -cryptography==41.0.7 -customtkinter==5.2.2 -Pillow==10.4.0 -psutil==5.9.8 -pystray==0.19.5 -pyperclip==1.9.0 diff --git a/requirements.txt b/requirements.txt deleted file mode 100644 index c7a85f3..0000000 --- a/requirements.txt +++ /dev/null @@ -1,6 +0,0 @@ -cryptography==46.0.5 -customtkinter==5.2.2 -Pillow==12.1.1 -psutil==7.0.0 -pystray==0.19.5 -pyperclip==1.9.0 diff --git a/windows.py b/windows.py index c96531d..568fce0 100644 --- a/windows.py +++ b/windows.py @@ -4,40 +4,51 @@ import ctypes import json import logging import os +import winreg import psutil import sys import threading import time import webbrowser -import pystray import pyperclip -import customtkinter as ctk +import asyncio as _asyncio from pathlib import Path -from typing import Optional +from typing import Dict, Optional + +import pystray +import customtkinter as ctk from PIL import Image, ImageDraw, ImageFont import proxy.tg_ws_proxy as tg_ws_proxy -from proxy.app_runtime import DEFAULT_CONFIG, ProxyAppRuntime +IS_FROZEN = bool(getattr(sys, "frozen", False)) + APP_NAME = "TgWsProxy" APP_DIR = Path(os.environ.get("APPDATA", Path.home())) / APP_NAME +CONFIG_FILE = APP_DIR / "config.json" +LOG_FILE = APP_DIR / "proxy.log" FIRST_RUN_MARKER = APP_DIR / ".first_run_done" IPV6_WARN_MARKER = APP_DIR / ".ipv6_warned" + + +DEFAULT_CONFIG = { + "port": 1080, + "host": "127.0.0.1", + "dc_ip": ["2:149.154.167.220", "4:149.154.167.220"], + "verbose": False, + "autostart": False, +} + + +_proxy_thread: Optional[threading.Thread] = None +_async_stop: Optional[object] = None _tray_icon: Optional[object] = None _config: dict = {} _exiting: bool = False _lock_file_path: Optional[Path] = None log = logging.getLogger("tg-ws-tray") -_runtime = ProxyAppRuntime( - APP_DIR, - default_config=DEFAULT_CONFIG, - logger_name="tg-ws-tray", - on_error=lambda text: _show_error(text), -) -CONFIG_FILE = _runtime.config_file -LOG_FILE = _runtime.log_file def _same_process(lock_meta: dict, proc: psutil.Process) -> bool: @@ -114,19 +125,106 @@ def _acquire_lock() -> bool: def _ensure_dirs(): - _runtime.ensure_dirs() + APP_DIR.mkdir(parents=True, exist_ok=True) def load_config() -> dict: - return _runtime.load_config() + _ensure_dirs() + if CONFIG_FILE.exists(): + try: + with open(CONFIG_FILE, "r", encoding="utf-8") as f: + data = json.load(f) + for k, v in DEFAULT_CONFIG.items(): + data.setdefault(k, v) + return data + except Exception as exc: + log.warning("Failed to load config: %s", exc) + return dict(DEFAULT_CONFIG) def save_config(cfg: dict): - _runtime.save_config(cfg) + _ensure_dirs() + with open(CONFIG_FILE, "w", encoding="utf-8") as f: + json.dump(cfg, f, indent=2, ensure_ascii=False) def setup_logging(verbose: bool = False): - _runtime.setup_logging(verbose) + _ensure_dirs() + root = logging.getLogger() + root.setLevel(logging.DEBUG if verbose else logging.INFO) + + fh = logging.FileHandler(str(LOG_FILE), encoding="utf-8") + fh.setLevel(logging.DEBUG) + fh.setFormatter(logging.Formatter( + "%(asctime)s %(levelname)-5s %(name)s %(message)s", + datefmt="%Y-%m-%d %H:%M:%S")) + root.addHandler(fh) + + if not getattr(sys, "frozen", False): + ch = logging.StreamHandler(sys.stdout) + ch.setLevel(logging.DEBUG if verbose else logging.INFO) + ch.setFormatter(logging.Formatter( + "%(asctime)s %(levelname)-5s %(message)s", + datefmt="%H:%M:%S")) + root.addHandler(ch) + + +def _autostart_reg_name() -> str: + return APP_NAME + + +def _supports_autostart() -> bool: + return IS_FROZEN + + +def _autostart_command() -> str: + return f'"{sys.executable}"' + + +def is_autostart_enabled() -> bool: + try: + with winreg.OpenKey( + winreg.HKEY_CURRENT_USER, + r"Software\Microsoft\Windows\CurrentVersion\Run", + 0, + winreg.KEY_READ, + ) as k: + val, _ = winreg.QueryValueEx(k, _autostart_reg_name()) + stored = str(val).strip() + expected = _autostart_command().strip() + return stored == expected + except FileNotFoundError: + return False + except OSError: + return False + + +def set_autostart_enabled(enabled: bool) -> None: + try: + with winreg.CreateKey( + winreg.HKEY_CURRENT_USER, + r"Software\Microsoft\Windows\CurrentVersion\Run", + ) as k: + if enabled: + winreg.SetValueEx( + k, + _autostart_reg_name(), + 0, + winreg.REG_SZ, + _autostart_command(), + ) + else: + try: + winreg.DeleteValue(k, _autostart_reg_name()) + except FileNotFoundError: + pass + except OSError as exc: + log.error("Failed to update autostart: %s", exc) + _show_error( + "Не удалось изменить автозапуск.\n\n" + "Попробуйте запустить приложение от имени пользователя с правами на реестр.\n\n" + f"Ошибка: {exc}" + ) def _make_icon_image(size: int = 64): @@ -161,16 +259,71 @@ def _load_icon(): pass return _make_icon_image() + + +def _run_proxy_thread(port: int, dc_opt: Dict[int, str], verbose: bool, + host: str = '127.0.0.1'): + global _async_stop + loop = _asyncio.new_event_loop() + _asyncio.set_event_loop(loop) + stop_ev = _asyncio.Event() + _async_stop = (loop, stop_ev) + + try: + loop.run_until_complete( + tg_ws_proxy._run(port, dc_opt, stop_event=stop_ev, host=host)) + except Exception as exc: + log.error("Proxy thread crashed: %s", exc) + if "10048" in str(exc) or "Address already in use" in str(exc): + _show_error("Не удалось запустить прокси:\nПорт уже используется другим приложением.\n\nЗакройте приложение, использующее этот порт, или измените порт в настройках прокси и перезапустите.") + finally: + loop.close() + _async_stop = None + + def start_proxy(): - _runtime.start_proxy(_config) + global _proxy_thread, _config + if _proxy_thread and _proxy_thread.is_alive(): + log.info("Proxy already running") + return + + cfg = _config + port = cfg.get("port", DEFAULT_CONFIG["port"]) + host = cfg.get("host", DEFAULT_CONFIG["host"]) + dc_ip_list = cfg.get("dc_ip", DEFAULT_CONFIG["dc_ip"]) + verbose = cfg.get("verbose", False) + + try: + dc_opt = tg_ws_proxy.parse_dc_ip_list(dc_ip_list) + except ValueError as e: + log.error("Bad config dc_ip: %s", e) + _show_error(f"Ошибка конфигурации:\n{e}") + return + + log.info("Starting proxy on %s:%d ...", host, port) + _proxy_thread = threading.Thread( + target=_run_proxy_thread, + args=(port, dc_opt, verbose, host), + daemon=True, name="proxy") + _proxy_thread.start() def stop_proxy(): - _runtime.stop_proxy() + global _proxy_thread, _async_stop + if _async_stop: + loop, stop_ev = _async_stop + loop.call_soon_threadsafe(stop_ev.set) + if _proxy_thread: + _proxy_thread.join(timeout=2) + _proxy_thread = None + log.info("Proxy stopped") def restart_proxy(): - _runtime.restart_proxy() + log.info("Restarting proxy...") + stop_proxy() + time.sleep(0.3) + start_proxy() def _show_error(text: str, title: str = "TG WS Proxy — Ошибка"): @@ -216,6 +369,12 @@ def _edit_config_dialog(): return cfg = dict(_config) + cfg["autostart"] = is_autostart_enabled() + + # Make sure that the autostart key is removed if autostart + # is disabled, even if the executable file is moved. + if _supports_autostart() and not cfg["autostart"]: + set_autostart_enabled(False) ctk.set_appearance_mode("light") ctk.set_default_color_theme("blue") @@ -224,6 +383,8 @@ def _edit_config_dialog(): root.title("TG WS Proxy — Настройки") root.resizable(False, False) root.attributes("-topmost", True) + icon_path = str(Path(__file__).parent / "icon.ico") + root.iconbitmap(icon_path) TG_BLUE = "#3390ec" TG_BLUE_HOVER = "#2b7cd4" @@ -234,7 +395,11 @@ def _edit_config_dialog(): TEXT_SECONDARY = "#707579" FONT_FAMILY = "Segoe UI" - w, h = 420, 480 + w, h = 420, 460 + + if _supports_autostart(): + h += 70 + sw = root.winfo_screenwidth() sh = root.winfo_screenheight() root.geometry(f"{w}x{h}+{(sw-w)//2}+{(sh-h)//2}") @@ -285,10 +450,18 @@ def _edit_config_dialog(): corner_radius=6, border_width=2, border_color=FIELD_BORDER).pack(anchor="w", pady=(0, 8)) - # Info label - ctk.CTkLabel(frame, text="Изменения вступят в силу после перезапуска прокси.", - font=(FONT_FAMILY, 11), text_color=TEXT_SECONDARY, - anchor="w").pack(anchor="w", pady=(0, 16)) + autostart_var = None + if _supports_autostart(): + autostart_var = ctk.BooleanVar(value=cfg["autostart"]) + ctk.CTkCheckBox(frame, text="Автозапуск при включении Windows", + variable=autostart_var, font=(FONT_FAMILY, 13), + text_color=TEXT_PRIMARY, + fg_color=TG_BLUE, hover_color=TG_BLUE_HOVER, + corner_radius=6, border_width=2, + border_color=FIELD_BORDER).pack(anchor="w", pady=(0, 8)) + ctk.CTkLabel(frame, text="При перемещении файла или открытии из другой папки\nавтозапуск будет сброшен", + font=(FONT_FAMILY, 13), text_color=TEXT_SECONDARY, + anchor="w", justify="left").pack(anchor="w", pady=(0, 8)) def on_save(): import socket as _sock @@ -320,11 +493,15 @@ def _edit_config_dialog(): "port": port_val, "dc_ip": lines, "verbose": verbose_var.get(), + "autostart": (autostart_var.get() if autostart_var is not None else False), } save_config(new_cfg) _config.update(new_cfg) log.info("Config saved: %s", new_cfg) + if _supports_autostart(): + set_autostart_enabled(bool(new_cfg.get("autostart", False))) + _tray_icon.menu = _build_menu() from tkinter import messagebox @@ -341,18 +518,18 @@ def _edit_config_dialog(): root.destroy() btn_frame = ctk.CTkFrame(frame, fg_color="transparent") - btn_frame.pack(fill="x") - ctk.CTkButton(btn_frame, text="Сохранить", width=140, height=38, + btn_frame.pack(fill="x", pady=(20, 0)) + ctk.CTkButton(btn_frame, text="Сохранить", height=38, font=(FONT_FAMILY, 14, "bold"), corner_radius=10, fg_color=TG_BLUE, hover_color=TG_BLUE_HOVER, text_color="#ffffff", - command=on_save).pack(side="left", padx=(0, 10)) - ctk.CTkButton(btn_frame, text="Отмена", width=140, height=38, + command=on_save).pack(side="left", fill="x", expand=True, padx=(0, 8)) + ctk.CTkButton(btn_frame, text="Отмена", height=38, font=(FONT_FAMILY, 14), corner_radius=10, fg_color=FIELD_BG, hover_color=FIELD_BORDER, text_color=TEXT_PRIMARY, border_width=1, border_color=FIELD_BORDER, - command=on_cancel).pack(side="left") + command=on_cancel).pack(side="right", fill="x", expand=True) root.mainloop() @@ -412,6 +589,8 @@ def _show_first_run(): root.title("TG WS Proxy") root.resizable(False, False) root.attributes("-topmost", True) + icon_path = str(Path(__file__).parent / "icon.ico") + root.iconbitmap(icon_path) w, h = 520, 440 sw = root.winfo_screenwidth() @@ -552,8 +731,14 @@ def _build_menu(): def run_tray(): global _tray_icon, _config - _config = _runtime.prepare() - _runtime.reset_log_file() + _config = load_config() + save_config(_config) + + if LOG_FILE.exists(): + try: + LOG_FILE.unlink() + except Exception: + pass setup_logging(_config.get("verbose", False)) log.info("TG WS Proxy tray app starting")