docs update

.github/cfproxy-domains.txt

@@ -0,0 +1,2 @@
+virkgj.com
+vmmzovy.com

.github/workflows/build.yml

@@ -16,9 +16,6 @@ on:
 permissions:
   contents: write
 
-env:
-  FORCE_JAVASCRIPT_ACTIONS_TO_NODE24: true
-
 jobs:
   build-windows:
     runs-on: windows-latest
@@ -32,15 +29,43 @@ jobs:
           python-version: "3.12"
           cache: "pip"
 
+      - name: Setup MSVC 14.40 toolset
+        uses: ilammy/msvc-dev-cmd@v1
+        with:
+          toolset: 14.40
+
       - name: Install dependencies
         run: pip install .
 
-      - name: Install pyinstaller
+      - name: Build PyInstaller bootloader from source
-        run: pip install "pyinstaller==6.13.0"
+        run: |
+          pip install "pyinstaller==6.16.0" --no-binary pyinstaller
+        env:
+          PYINSTALLER_COMPILE_BOOTLOADER: 1
 
       - name: Build EXE with PyInstaller
         run: pyinstaller packaging/windows.spec --noconfirm
 
+      - name: Strip Rich PE header
+        shell: bash
+        run: |
+          python -c "
+          import struct, pathlib
+          exe = pathlib.Path('dist/TgWsProxy.exe')
+          data = bytearray(exe.read_bytes())
+          rich = data.find(b'Rich')
+          if rich == -1:
+              raise SystemExit('Rich header not found')
+          ck = struct.unpack_from('<I', data, rich + 4)[0]
+          dans = struct.pack('<I', 0x536E6144 ^ ck)
+          ds = data.find(dans)
+          if ds == -1:
+              raise SystemExit('DanS marker not found')
+          data[ds:rich + 8] = b'\x00' * (rich + 8 - ds)
+          exe.write_bytes(data)
+          print(f'Stripped Rich header: offset {ds}..{rich+8}')
+          "
+
       - name: Rename artifact
         run: mv dist/TgWsProxy.exe dist/TgWsProxy_windows.exe
 
@@ -74,6 +99,26 @@ jobs:
       - name: Build EXE with PyInstaller
         run: pyinstaller packaging/windows.spec --noconfirm
 
+      - name: Strip Rich PE header
+        shell: bash
+        run: |
+          python -c "
+          import struct, pathlib
+          exe = pathlib.Path('dist/TgWsProxy.exe')
+          data = bytearray(exe.read_bytes())
+          rich = data.find(b'Rich')
+          if rich == -1:
+              raise SystemExit('Rich header not found')
+          ck = struct.unpack_from('<I', data, rich + 4)[0]
+          dans = struct.pack('<I', 0x536E6144 ^ ck)
+          ds = data.find(dans)
+          if ds == -1:
+              raise SystemExit('DanS marker not found')
+          data[ds:rich + 8] = b'\x00' * (rich + 8 - ds)
+          exe.write_bytes(data)
+          print(f'Stripped Rich header: offset {ds}..{rich+8}')
+          "
+
       - name: Rename artifact
         run: mv dist/TgWsProxy.exe dist/TgWsProxy_windows_7_${{ matrix.suffix }}.exe
 
@@ -148,7 +193,7 @@ jobs:
 
           python3.12 -m pip install --no-deps wheelhouse/universal2/*.whl
           python3.12 -m pip install .
-          python3.12 -m pip install pyinstaller==6.13.0
+          python3.12 -m pip install pyinstaller==6.16.0
 
       - name: Create macOS icon from ICO
         run: |
@@ -250,7 +295,7 @@ jobs:
         run: |
           .venv/bin/pip install --upgrade pip
           .venv/bin/pip install .
-          .venv/bin/pip install "pyinstaller==6.13.0"
+          .venv/bin/pip install "pyinstaller==6.16.0"
 
       - name: Build binary with PyInstaller
         run: .venv/bin/pyinstaller packaging/linux.spec --noconfirm
@@ -306,7 +351,7 @@ jobs:
           Maintainer: Flowseal
           Depends: libgtk-3-0, libayatana-appindicator3-1, python3-tk
           Description: Telegram Desktop WebSocket Bridge Proxy
-           SOCKS5/WebSocket bridge proxy for Telegram Desktop with tray UI.
+           MTProto/WebSocket bridge proxy for Telegram Desktop with tray UI.
           EOF
 
           dpkg-deb --build --root-owner-group \
@@ -321,99 +366,8 @@ jobs:
             dist/TgWsProxy_linux_amd64
             dist/TgWsProxy_linux_amd64.deb
 
-  build-android:
-    runs-on: ubuntu-latest
-    timeout-minutes: 30
-    env:
-      ANDROID_APK_STANDARD_NAME: tg-ws-proxy-android-${{ github.event.inputs.version }}.apk
-      ANDROID_APK_LEGACY32_NAME: tg-ws-proxy-android-${{ github.event.inputs.version }}-legacy32.apk
-    defaults:
-      run:
-        working-directory: android
-    steps:
-      - name: Checkout
-        uses: actions/checkout@v6
-
-      - name: Validate Android release signing secrets
-        env:
-          ANDROID_KEYSTORE_BASE64: ${{ secrets.ANDROID_KEYSTORE_BASE64 }}
-          ANDROID_KEYSTORE_PASSWORD: ${{ secrets.ANDROID_KEYSTORE_PASSWORD }}
-          ANDROID_KEY_ALIAS: ${{ secrets.ANDROID_KEY_ALIAS }}
-          ANDROID_KEY_PASSWORD: ${{ secrets.ANDROID_KEY_PASSWORD }}
-        run: |
-          test -n "$ANDROID_KEYSTORE_BASE64" || { echo "Missing secret: ANDROID_KEYSTORE_BASE64"; exit 1; }
-          test -n "$ANDROID_KEYSTORE_PASSWORD" || { echo "Missing secret: ANDROID_KEYSTORE_PASSWORD"; exit 1; }
-          test -n "$ANDROID_KEY_ALIAS" || { echo "Missing secret: ANDROID_KEY_ALIAS"; exit 1; }
-          test -n "$ANDROID_KEY_PASSWORD" || { echo "Missing secret: ANDROID_KEY_PASSWORD"; exit 1; }
-
-      - name: Set up JDK 17
-        uses: actions/setup-java@v5
-        with:
-          distribution: temurin
-          java-version: "17"
-          cache: gradle
-          cache-dependency-path: |
-            android/settings.gradle.kts
-            android/build.gradle.kts
-            android/gradle.properties
-            android/app/build.gradle.kts
-
-      - name: Set up Python 3.12
-        uses: actions/setup-python@v6
-        with:
-          python-version: "3.12"
-
-      - name: Set up Android SDK
-        uses: android-actions/setup-android@v3
-
-      - name: Accept Android SDK licenses
-        run: yes | sdkmanager --licenses > /dev/null
-
-      - name: Install Android SDK packages
-        run: sdkmanager "platforms;android-34" "build-tools;34.0.0"
-
-      - name: Prepare Android release keystore
-        env:
-          ANDROID_KEYSTORE_BASE64: ${{ secrets.ANDROID_KEYSTORE_BASE64 }}
-        run: |
-          printf '%s' "$ANDROID_KEYSTORE_BASE64" | base64 --decode > "$RUNNER_TEMP/android-release.keystore"
-          test -s "$RUNNER_TEMP/android-release.keystore"
-
-      - name: Build Android release APKs
-        env:
-          LOCAL_CHAQUOPY_REPO: ${{ github.workspace }}/android/.m2-chaquopy-ci
-          ANDROID_KEYSTORE_FILE: ${{ runner.temp }}/android-release.keystore
-          ANDROID_KEYSTORE_PASSWORD: ${{ secrets.ANDROID_KEYSTORE_PASSWORD }}
-          ANDROID_KEY_ALIAS: ${{ secrets.ANDROID_KEY_ALIAS }}
-          ANDROID_KEY_PASSWORD: ${{ secrets.ANDROID_KEY_PASSWORD }}
-        run: |
-          chmod +x gradlew build-local-debug.sh
-          ./build-local-debug.sh assembleStandardRelease
-          ./build-local-debug.sh assembleLegacy32Release
-
-      - name: Rename APKs
-        run: |
-          cp app/build/outputs/apk/standard/release/app-standard-release.apk \
-            "app/build/outputs/apk/standard/release/$ANDROID_APK_STANDARD_NAME"
-          cp app/build/outputs/apk/legacy32/release/app-legacy32-release.apk \
-            "app/build/outputs/apk/legacy32/release/$ANDROID_APK_LEGACY32_NAME"
-
-      - name: Stage Android release artifacts
-        run: |
-          mkdir -p dist
-          cp "app/build/outputs/apk/standard/release/$ANDROID_APK_STANDARD_NAME" "dist/$ANDROID_APK_STANDARD_NAME"
-          cp "app/build/outputs/apk/legacy32/release/$ANDROID_APK_LEGACY32_NAME" "dist/$ANDROID_APK_LEGACY32_NAME"
-
-      - name: Upload artifact
-        uses: actions/upload-artifact@v7
-        with:
-          name: TgWsProxy-android-release
-          path: |
-            android/dist/${{ env.ANDROID_APK_STANDARD_NAME }}
-            android/dist/${{ env.ANDROID_APK_LEGACY32_NAME }}
-
   release:
-    needs: [build-windows, build-win7, build-macos, build-linux, build-android]
+    needs: [build-windows, build-win7, build-macos, build-linux]
     runs-on: ubuntu-latest
     if: ${{ github.event.inputs.make_release == 'true' }}
     steps:
@@ -423,12 +377,6 @@ jobs:
           path: dist
           merge-multiple: true
 
-      - name: Download Android build
-        uses: actions/download-artifact@v8
-        with:
-          name: TgWsProxy-android-release
-          path: dist
-
       - name: Create GitHub Release
         uses: softprops/action-gh-release@v2
         with:
@@ -443,8 +391,6 @@ jobs:
             dist/TgWsProxy_macos_universal.dmg
             dist/TgWsProxy_linux_amd64
             dist/TgWsProxy_linux_amd64.deb
-            dist/tg-ws-proxy-android-${{ github.event.inputs.version }}.apk
-            dist/tg-ws-proxy-android-${{ github.event.inputs.version }}-legacy32.apk
           draft: false
           prerelease: false
         env:

.gitignore

@@ -16,17 +16,6 @@ build/
 .idea/
 *.swp
 *.swo
-.gradle/
-.gradle-local/
-android/.gradle-local/
-android/.m2-chaquopy*/
-local.properties
-android/.idea/
-android/build/
-android/app/build/
-android/*.jks
-*.keystore
-android/*.keystore.properties
 
 # OS
 Thumbs.db

Dockerfile

@@ -23,7 +23,7 @@ ENV PYTHONDONTWRITEBYTECODE=1 \
     PYTHONUNBUFFERED=1 \
     PATH=/opt/venv/bin:$PATH \
     TG_WS_PROXY_HOST=0.0.0.0 \
-    TG_WS_PROXY_PORT=1080 \
+    TG_WS_PROXY_PORT=1443 \
     TG_WS_PROXY_DC_IPS="2:149.154.167.220 4:149.154.167.220"
 
 RUN apt-get update \
@@ -35,11 +35,11 @@ RUN apt-get update \
 WORKDIR /app
 COPY --from=builder /opt/venv /opt/venv
 COPY proxy ./proxy
-COPY README.md LICENSE ./
+COPY docs/README.md LICENSE ./
 
 USER app
 
-EXPOSE 1080/tcp
+EXPOSE 1443/tcp
 
 ENTRYPOINT ["/usr/bin/tini", "--", "/bin/sh", "-lc", "set -eu; args=\"--host ${TG_WS_PROXY_HOST} --port ${TG_WS_PROXY_PORT}\"; for dc in ${TG_WS_PROXY_DC_IPS}; do args=\"$args --dc-ip $dc\"; done; exec python -u proxy/tg_ws_proxy.py $args \"$@\"", "--"]
 CMD []

android/app/build.gradle.kts

@@ -1,170 +0,0 @@
-import org.gradle.api.tasks.Sync
-import org.gradle.api.GradleException
-import java.io.File
-
-plugins {
-    id("com.android.application")
-    id("com.chaquo.python")
-    id("org.jetbrains.kotlin.android")
-}
-
-fun loadProxyVersionName(): String {
-    val versionFile = rootProject.projectDir.resolve("../proxy/__init__.py")
-    val match = Regex("""__version__\s*=\s*"([^"]+)"""")
-        .find(versionFile.readText())
-        ?: throw GradleException("Failed to parse proxy version from ${versionFile.absolutePath}")
-    return match.groupValues[1]
-}
-
-data class ReleaseSigningEnv(
-    val keystoreFile: File,
-    val storePassword: String,
-    val keyAlias: String,
-    val keyPassword: String,
-)
-
-fun requiredEnv(name: String): String {
-    return System.getenv(name)?.takeIf { it.isNotBlank() }
-        ?: throw GradleException("Missing required environment variable: $name")
-}
-
-fun loadReleaseSigningEnv(releaseSigningRequested: Boolean): ReleaseSigningEnv? {
-    val keystorePath = System.getenv("ANDROID_KEYSTORE_FILE")?.takeIf { it.isNotBlank() }
-    val anySigningEnvProvided = listOf(
-        keystorePath,
-        System.getenv("ANDROID_KEYSTORE_PASSWORD"),
-        System.getenv("ANDROID_KEY_ALIAS"),
-        System.getenv("ANDROID_KEY_PASSWORD"),
-    ).any { !it.isNullOrBlank() }
-
-    if (!releaseSigningRequested && !anySigningEnvProvided) {
-        return null
-    }
-
-    val keystoreFile = File(requiredEnv("ANDROID_KEYSTORE_FILE"))
-    if (!keystoreFile.isFile) {
-        throw GradleException("ANDROID_KEYSTORE_FILE does not exist: ${keystoreFile.absolutePath}")
-    }
-
-    return ReleaseSigningEnv(
-        keystoreFile = keystoreFile,
-        storePassword = requiredEnv("ANDROID_KEYSTORE_PASSWORD"),
-        keyAlias = requiredEnv("ANDROID_KEY_ALIAS"),
-        keyPassword = requiredEnv("ANDROID_KEY_PASSWORD"),
-    )
-}
-
-val stagedPythonSourcesDir = layout.buildDirectory.dir("generated/chaquopy/python")
-val stagePythonSources by tasks.registering(Sync::class) {
-    from(rootProject.projectDir.resolve("../proxy")) {
-        into("proxy")
-    }
-    from(rootProject.projectDir.resolve("../utils")) {
-        into("utils")
-    }
-    into(stagedPythonSourcesDir)
-}
-val releaseSigningRequested = gradle.startParameter.taskNames.any {
-    it.contains("release", ignoreCase = true)
-}
-val releaseSigningEnv = loadReleaseSigningEnv(releaseSigningRequested)
-val appVersionName = loadProxyVersionName()
-
-android {
-    namespace = "org.flowseal.tgwsproxy"
-    compileSdk = 34
-
-    defaultConfig {
-        applicationId = "org.flowseal.tgwsproxy"
-        minSdk = 26
-        targetSdk = 34
-        versionCode = 1
-        versionName = appVersionName
-
-        testInstrumentationRunner = "androidx.test.runner.AndroidJUnitRunner"
-    }
-
-    flavorDimensions += "runtime"
-    productFlavors {
-        create("standard") {
-            dimension = "runtime"
-            ndk {
-                abiFilters += listOf("arm64-v8a", "x86_64")
-            }
-        }
-        create("legacy32") {
-            dimension = "runtime"
-            versionNameSuffix = "-legacy32"
-            ndk {
-                abiFilters += listOf("armeabi-v7a")
-            }
-        }
-    }
-
-    signingConfigs {
-        if (releaseSigningEnv != null) {
-            create("release") {
-                storeFile = releaseSigningEnv.keystoreFile
-                storePassword = releaseSigningEnv.storePassword
-                keyAlias = releaseSigningEnv.keyAlias
-                keyPassword = releaseSigningEnv.keyPassword
-            }
-        }
-    }
-
-    buildTypes {
-        release {
-            isMinifyEnabled = false
-            proguardFiles(
-                getDefaultProguardFile("proguard-android-optimize.txt"),
-                "proguard-rules.pro",
-            )
-            if (releaseSigningEnv != null) {
-                signingConfig = signingConfigs.getByName("release")
-            }
-        }
-    }
-
-    compileOptions {
-        sourceCompatibility = JavaVersion.VERSION_17
-        targetCompatibility = JavaVersion.VERSION_17
-    }
-
-    kotlinOptions {
-        jvmTarget = "17"
-    }
-
-    buildFeatures {
-        viewBinding = true
-    }
-}
-
-chaquopy {
-    productFlavors {
-        getByName("standard") {
-            version = "3.12"
-        }
-        getByName("legacy32") {
-            version = "3.11"
-        }
-    }
-    sourceSets {
-        getByName("main") {
-            srcDir("src/main/python")
-            srcDir(stagePythonSources)
-        }
-    }
-}
-
-dependencies {
-    implementation("androidx.core:core-ktx:1.13.1")
-    implementation("androidx.appcompat:appcompat:1.7.0")
-    implementation("androidx.activity:activity-ktx:1.9.2")
-    implementation("androidx.lifecycle:lifecycle-runtime-ktx:2.8.6")
-    implementation("androidx.lifecycle:lifecycle-service:2.8.6")
-    implementation("com.google.android.material:material:1.12.0")
-
-    testImplementation("junit:junit:4.13.2")
-    androidTestImplementation("androidx.test.ext:junit:1.2.1")
-    androidTestImplementation("androidx.test.espresso:espresso-core:3.6.1")
-}

android/app/proguard-rules.pro

@@ -1 +0,0 @@
-# Intentionally empty for the initial Android shell.

android/app/src/main/AndroidManifest.xml

@@ -1,39 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<manifest xmlns:android="http://schemas.android.com/apk/res/android">
-
-    <uses-permission android:name="android.permission.INTERNET" />
-    <uses-permission android:name="android.permission.FOREGROUND_SERVICE" />
-    <uses-permission android:name="android.permission.FOREGROUND_SERVICE_DATA_SYNC" />
-    <uses-permission android:name="android.permission.POST_NOTIFICATIONS" />
-    <uses-permission android:name="android.permission.REQUEST_IGNORE_BATTERY_OPTIMIZATIONS" />
-
-    <application
-        android:allowBackup="true"
-        android:icon="@drawable/ic_proxy_app"
-        android:label="@string/app_name"
-        android:roundIcon="@drawable/ic_proxy_app"
-        android:supportsRtl="true"
-        android:theme="@style/Theme.TgWsProxy">
-
-        <activity
-            android:name=".LogViewerActivity"
-            android:exported="false" />
-
-        <activity
-            android:name=".MainActivity"
-            android:exported="true">
-            <intent-filter>
-                <action android:name="android.intent.action.MAIN" />
-
-                <category android:name="android.intent.category.LAUNCHER" />
-            </intent-filter>
-        </activity>
-
-        <service
-            android:name=".ProxyForegroundService"
-            android:enabled="true"
-            android:exported="false"
-            android:foregroundServiceType="dataSync" />
-    </application>
-
-</manifest>

android/app/src/main/java/org/flowseal/tgwsproxy/AndroidSystemStatus.kt

@@ -1,62 +0,0 @@
-package org.flowseal.tgwsproxy
-
-import android.app.ActivityManager
-import android.content.Context
-import android.content.Intent
-import android.net.Uri
-import android.os.Build
-import android.os.PowerManager
-import android.provider.Settings
-
-data class AndroidSystemStatus(
-    val ignoringBatteryOptimizations: Boolean,
-    val backgroundRestricted: Boolean,
-) {
-    val canKeepRunningReliably: Boolean
-        get() = ignoringBatteryOptimizations && !backgroundRestricted
-
-    companion object {
-        fun read(context: Context): AndroidSystemStatus {
-            val powerManager = context.getSystemService(Context.POWER_SERVICE) as PowerManager
-            val activityManager = context.getSystemService(Context.ACTIVITY_SERVICE) as ActivityManager
-
-            val ignoringBatteryOptimizations = if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) {
-                powerManager.isIgnoringBatteryOptimizations(context.packageName)
-            } else {
-                true
-            }
-
-            val backgroundRestricted = if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.P) {
-                activityManager.isBackgroundRestricted
-            } else {
-                false
-            }
-
-            return AndroidSystemStatus(
-                ignoringBatteryOptimizations = ignoringBatteryOptimizations,
-                backgroundRestricted = backgroundRestricted,
-            )
-        }
-
-        fun openBatteryOptimizationSettings(context: Context) {
-            val intent = if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) {
-                Intent(Settings.ACTION_REQUEST_IGNORE_BATTERY_OPTIMIZATIONS).apply {
-                    data = Uri.parse("package:${context.packageName}")
-                }
-            } else {
-                Intent(Settings.ACTION_APPLICATION_DETAILS_SETTINGS).apply {
-                    data = Uri.fromParts("package", context.packageName, null)
-                }
-            }
-
-            context.startActivity(intent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK))
-        }
-
-        fun openAppSettings(context: Context) {
-            val intent = Intent(Settings.ACTION_APPLICATION_DETAILS_SETTINGS).apply {
-                data = Uri.fromParts("package", context.packageName, null)
-            }
-            context.startActivity(intent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK))
-        }
-    }
-}

android/app/src/main/java/org/flowseal/tgwsproxy/LogViewerActivity.kt

@@ -1,53 +0,0 @@
-package org.flowseal.tgwsproxy
-
-import android.os.Bundle
-import androidx.appcompat.app.AppCompatActivity
-import org.flowseal.tgwsproxy.databinding.ActivityLogViewerBinding
-import java.io.File
-
-class LogViewerActivity : AppCompatActivity() {
-    private lateinit var binding: ActivityLogViewerBinding
-
-    override fun onCreate(savedInstanceState: Bundle?) {
-        super.onCreate(savedInstanceState)
-        binding = ActivityLogViewerBinding.inflate(layoutInflater)
-        setContentView(binding.root)
-
-        binding.refreshLogsButton.setOnClickListener { renderLog() }
-        binding.closeLogsButton.setOnClickListener { finish() }
-
-        renderLog()
-    }
-
-    override fun onResume() {
-        super.onResume()
-        renderLog()
-    }
-
-    private fun renderLog() {
-        val logFile = File(filesDir, "tg-ws-proxy/proxy.log")
-        binding.logPathValue.text = logFile.absolutePath
-        binding.logContentValue.text = readLogTail(logFile)
-    }
-
-    private fun readLogTail(logFile: File, maxChars: Int = 40000): String {
-        if (!logFile.isFile) {
-            return getString(R.string.logs_empty)
-        }
-
-        val text = runCatching {
-            logFile.readText(Charsets.UTF_8)
-        }.getOrElse { error ->
-            return getString(R.string.logs_read_failed, error.message ?: error.javaClass.simpleName)
-        }
-
-        if (text.isBlank()) {
-            return getString(R.string.logs_empty)
-        }
-        if (text.length <= maxChars) {
-            return text
-        }
-
-        return getString(R.string.logs_truncated_prefix) + "\n\n" + text.takeLast(maxChars)
-    }
-}

android/app/src/main/java/org/flowseal/tgwsproxy/MainActivity.kt

@@ -1,328 +0,0 @@
-package org.flowseal.tgwsproxy
-
-import android.Manifest
-import android.content.Intent
-import android.content.pm.PackageManager
-import android.net.Uri
-import android.os.Build
-import android.os.Bundle
-import android.widget.Toast
-import androidx.activity.result.contract.ActivityResultContracts
-import androidx.appcompat.app.AppCompatActivity
-import androidx.core.content.ContextCompat
-import androidx.core.view.isVisible
-import androidx.lifecycle.Lifecycle
-import androidx.lifecycle.lifecycleScope
-import androidx.lifecycle.repeatOnLifecycle
-import com.google.android.material.snackbar.Snackbar
-import kotlinx.coroutines.Dispatchers
-import kotlinx.coroutines.flow.combine
-import kotlinx.coroutines.launch
-import kotlinx.coroutines.withContext
-import org.flowseal.tgwsproxy.databinding.ActivityMainBinding
-
-class MainActivity : AppCompatActivity() {
-    private lateinit var binding: ActivityMainBinding
-    private lateinit var settingsStore: ProxySettingsStore
-    private var currentUpdateStatus: ProxyUpdateStatus? = null
-
-    private val notificationPermissionLauncher = registerForActivityResult(
-        ActivityResultContracts.RequestPermission(),
-    ) { granted ->
-        if (!granted) {
-            Toast.makeText(
-                this,
-                "Без уведомлений Android может скрыть foreground service.",
-                Toast.LENGTH_LONG,
-            ).show()
-        }
-    }
-
-    override fun onCreate(savedInstanceState: Bundle?) {
-        super.onCreate(savedInstanceState)
-        binding = ActivityMainBinding.inflate(layoutInflater)
-        settingsStore = ProxySettingsStore(this)
-        setContentView(binding.root)
-
-        binding.startButton.setOnClickListener { onStartClicked() }
-        binding.stopButton.setOnClickListener { ProxyForegroundService.stop(this) }
-        binding.restartButton.setOnClickListener { onRestartClicked() }
-        binding.saveButton.setOnClickListener { onSaveClicked(showMessage = true) }
-        binding.openLogsButton.setOnClickListener { onOpenLogsClicked() }
-        binding.openTelegramButton.setOnClickListener { onOpenTelegramClicked() }
-        binding.openReleasePageButton.setOnClickListener { onOpenReleasePageClicked() }
-        binding.checkUpdatesSwitch.setOnCheckedChangeListener { _, _ ->
-            renderUpdateStatus(currentUpdateStatus, binding.checkUpdatesSwitch.isChecked)
-        }
-        binding.disableBatteryOptimizationButton.setOnClickListener {
-            AndroidSystemStatus.openBatteryOptimizationSettings(this)
-        }
-        binding.openAppSettingsButton.setOnClickListener {
-            AndroidSystemStatus.openAppSettings(this)
-        }
-
-        val config = settingsStore.load()
-        renderConfig(config)
-        if (config.checkUpdates) {
-            refreshUpdateStatus(checkNow = true)
-        } else {
-            currentUpdateStatus = null
-            renderUpdateStatus(null, false)
-        }
-        requestNotificationPermissionIfNeeded()
-        observeServiceState()
-        renderSystemStatus()
-    }
-
-    override fun onResume() {
-        super.onResume()
-        renderSystemStatus()
-    }
-
-    private fun onSaveClicked(showMessage: Boolean): NormalizedProxyConfig? {
-        val validation = collectConfigFromForm().validate()
-        val config = validation.normalized
-        if (config == null) {
-            binding.errorText.text = validation.errorMessage
-            binding.errorText.isVisible = true
-            return null
-        }
-
-        binding.errorText.isVisible = false
-        settingsStore.save(config)
-        if (showMessage) {
-            Snackbar.make(binding.root, R.string.settings_saved, Snackbar.LENGTH_SHORT).show()
-        }
-        if (config.checkUpdates) {
-            refreshUpdateStatus(checkNow = true)
-        } else {
-            currentUpdateStatus = null
-            renderUpdateStatus(null, false)
-        }
-        return config
-    }
-
-    private fun onStartClicked() {
-        onSaveClicked(showMessage = false) ?: return
-        ProxyForegroundService.start(this)
-        Snackbar.make(binding.root, R.string.service_start_requested, Snackbar.LENGTH_SHORT).show()
-    }
-
-    private fun onRestartClicked() {
-        onSaveClicked(showMessage = false) ?: return
-        ProxyForegroundService.restart(this)
-        Snackbar.make(binding.root, R.string.service_restart_requested, Snackbar.LENGTH_SHORT).show()
-    }
-
-    private fun onOpenLogsClicked() {
-        startActivity(Intent(this, LogViewerActivity::class.java))
-    }
-
-    private fun onOpenTelegramClicked() {
-        val config = onSaveClicked(showMessage = false) ?: return
-        if (!TelegramProxyIntent.open(this, config)) {
-            Snackbar.make(binding.root, R.string.telegram_not_found, Snackbar.LENGTH_LONG).show()
-        }
-    }
-
-    private fun renderConfig(config: ProxyConfig) {
-        binding.hostInput.setText(config.host)
-        binding.portInput.setText(config.portText)
-        binding.dcIpInput.setText(config.dcIpText)
-        binding.logMaxMbInput.setText(config.logMaxMbText)
-        binding.bufferKbInput.setText(config.bufferKbText)
-        binding.poolSizeInput.setText(config.poolSizeText)
-        binding.checkUpdatesSwitch.isChecked = config.checkUpdates
-        binding.verboseSwitch.isChecked = config.verbose
-        renderUpdateStatus(currentUpdateStatus, config.checkUpdates)
-    }
-
-    private fun collectConfigFromForm(): ProxyConfig {
-        return ProxyConfig(
-            host = binding.hostInput.text?.toString().orEmpty(),
-            portText = binding.portInput.text?.toString().orEmpty(),
-            dcIpText = binding.dcIpInput.text?.toString().orEmpty(),
-            logMaxMbText = binding.logMaxMbInput.text?.toString().orEmpty(),
-            bufferKbText = binding.bufferKbInput.text?.toString().orEmpty(),
-            poolSizeText = binding.poolSizeInput.text?.toString().orEmpty(),
-            checkUpdates = binding.checkUpdatesSwitch.isChecked,
-            verbose = binding.verboseSwitch.isChecked,
-        )
-    }
-
-    private fun onOpenReleasePageClicked() {
-        val url = currentUpdateStatus?.htmlUrl ?: "https://github.com/Dark-Avery/tg-ws-proxy/releases/latest"
-        val opened = runCatching {
-            startActivity(Intent(Intent.ACTION_VIEW, Uri.parse(url)))
-        }.isSuccess
-        if (!opened) {
-            Snackbar.make(binding.root, R.string.release_page_open_failed, Snackbar.LENGTH_LONG).show()
-        }
-    }
-
-    private fun refreshUpdateStatus(checkNow: Boolean) {
-        lifecycleScope.launch {
-            val status = runCatching {
-                withContext(Dispatchers.IO) {
-                    PythonProxyBridge.getUpdateStatus(this@MainActivity, checkNow)
-                }
-            }.getOrElse { exc ->
-                ProxyUpdateStatus(
-                    currentVersion = "unknown",
-                    error = exc.message ?: exc.javaClass.simpleName,
-                )
-            }
-            currentUpdateStatus = status
-            renderUpdateStatus(status, binding.checkUpdatesSwitch.isChecked)
-        }
-    }
-
-    private fun renderUpdateStatus(status: ProxyUpdateStatus?, checkUpdatesEnabled: Boolean) {
-        val currentVersion = status?.currentVersion?.takeIf { it.isNotBlank() } ?: currentAppVersionName()
-        binding.currentVersionValue.text = getString(
-            R.string.updates_current_version_format,
-            currentVersion,
-        )
-        binding.updateStatusValue.text = when {
-            !checkUpdatesEnabled -> {
-                getString(R.string.updates_status_disabled)
-            }
-            status == null -> {
-                getString(R.string.updates_status_initial)
-            }
-            !status.error.isNullOrBlank() -> {
-                getString(R.string.updates_status_error, status.error)
-            }
-            !status.checked -> {
-                getString(R.string.updates_status_idle)
-            }
-            status.hasUpdate && !status.latestVersion.isNullOrBlank() -> {
-                getString(
-                    R.string.updates_status_available,
-                    status.latestVersion,
-                    status.currentVersion,
-                )
-            }
-            status.aheadOfRelease -> {
-                getString(R.string.updates_status_newer, status.currentVersion)
-            }
-            else -> {
-                getString(R.string.updates_status_latest, status.currentVersion)
-            }
-        }
-    }
-
-    private fun currentAppVersionName(): String {
-        return runCatching {
-            @Suppress("DEPRECATION")
-            packageManager.getPackageInfo(packageName, 0).versionName
-        }.getOrNull().orEmpty().ifBlank { "unknown" }
-    }
-
-    private fun observeServiceState() {
-        lifecycleScope.launch {
-            repeatOnLifecycle(Lifecycle.State.STARTED) {
-                combine(
-                    ProxyServiceState.isStarting,
-                    ProxyServiceState.isRunning,
-                ) { isStarting, isRunning ->
-                    isStarting to isRunning
-                }.collect { (isStarting, isRunning) ->
-                    binding.statusValue.text = getString(
-                        when {
-                            isStarting -> R.string.status_starting
-                            isRunning -> R.string.status_running
-                            else -> R.string.status_stopped
-                        },
-                    )
-                    binding.startButton.isEnabled = !isStarting && !isRunning
-                    binding.stopButton.isEnabled = isStarting || isRunning
-                    binding.restartButton.isEnabled = !isStarting
-                }
-            }
-        }
-
-        lifecycleScope.launch {
-            repeatOnLifecycle(Lifecycle.State.STARTED) {
-                combine(
-                    ProxyServiceState.activeConfig,
-                    ProxyServiceState.isStarting,
-                ) { config, isStarting ->
-                    config to isStarting
-                }.collect { (config, isStarting) ->
-                    binding.serviceHint.text = if (config == null) {
-                        getString(R.string.service_hint_idle)
-                    } else if (isStarting) {
-                        getString(
-                            R.string.service_hint_starting,
-                            config.host,
-                            config.port,
-                        )
-                    } else {
-                        getString(
-                            R.string.service_hint_running,
-                            config.host,
-                            config.port,
-                        )
-                    }
-                }
-            }
-        }
-
-        lifecycleScope.launch {
-            repeatOnLifecycle(Lifecycle.State.STARTED) {
-                ProxyServiceState.lastError.collect { error ->
-                    if (error.isNullOrBlank()) {
-                        binding.lastErrorCard.isVisible = false
-                    } else {
-                        binding.lastErrorValue.text = error
-                        binding.lastErrorCard.isVisible = true
-                    }
-                }
-            }
-        }
-    }
-
-    private fun renderSystemStatus() {
-        val status = AndroidSystemStatus.read(this)
-
-        binding.systemStatusValue.text = getString(
-            if (status.canKeepRunningReliably) {
-                R.string.system_status_ready
-            } else {
-                R.string.system_status_attention
-            },
-        )
-
-        val lines = mutableListOf<String>()
-        lines += if (status.ignoringBatteryOptimizations) {
-            getString(R.string.system_check_battery_ignored)
-        } else {
-            getString(R.string.system_check_battery_active)
-        }
-        lines += if (status.backgroundRestricted) {
-            getString(R.string.system_check_background_restricted)
-        } else {
-            getString(R.string.system_check_background_ok)
-        }
-        lines += getString(R.string.system_check_oem_note)
-        binding.systemStatusHint.text = lines.joinToString("\n")
-
-        binding.disableBatteryOptimizationButton.isVisible = !status.ignoringBatteryOptimizations
-        binding.openAppSettingsButton.isVisible = status.backgroundRestricted || !status.ignoringBatteryOptimizations
-    }
-
-    private fun requestNotificationPermissionIfNeeded() {
-        if (Build.VERSION.SDK_INT < Build.VERSION_CODES.TIRAMISU) {
-            return
-        }
-        if (ContextCompat.checkSelfPermission(
-                this,
-                Manifest.permission.POST_NOTIFICATIONS,
-            ) == PackageManager.PERMISSION_GRANTED
-        ) {
-            return
-        }
-        notificationPermissionLauncher.launch(Manifest.permission.POST_NOTIFICATIONS)
-    }
-}

android/app/src/main/java/org/flowseal/tgwsproxy/ProxyConfig.kt

@@ -1,137 +0,0 @@
-package org.flowseal.tgwsproxy
-
-data class ProxyConfig(
-    val host: String = DEFAULT_HOST,
-    val portText: String = DEFAULT_PORT.toString(),
-    val dcIpText: String = DEFAULT_DC_IP_LINES.joinToString("\n"),
-    val logMaxMbText: String = formatDecimal(DEFAULT_LOG_MAX_MB),
-    val bufferKbText: String = DEFAULT_BUFFER_KB.toString(),
-    val poolSizeText: String = DEFAULT_POOL_SIZE.toString(),
-    val checkUpdates: Boolean = false,
-    val verbose: Boolean = false,
-) {
-    fun validate(): ValidationResult {
-        val hostValue = host.trim()
-        if (!isIpv4Address(hostValue)) {
-            return ValidationResult(errorMessage = "IP-адрес прокси указан некорректно.")
-        }
-
-        val portValue = portText.trim().toIntOrNull()
-            ?: return ValidationResult(errorMessage = "Порт должен быть числом.")
-        if (portValue !in 1..65535) {
-            return ValidationResult(errorMessage = "Порт должен быть в диапазоне 1-65535.")
-        }
-
-        val lines = dcIpText
-            .lineSequence()
-            .map { it.trim() }
-            .filter { it.isNotEmpty() }
-            .toList()
-
-        if (lines.isEmpty()) {
-            return ValidationResult(errorMessage = "Добавьте хотя бы один DC:IP маппинг.")
-        }
-
-        for (line in lines) {
-            val parts = line.split(":", limit = 2)
-            val dcValue = parts.firstOrNull()?.toIntOrNull()
-            val ipValue = parts.getOrNull(1)?.trim().orEmpty()
-            if (parts.size != 2 || dcValue == null || !isIpv4Address(ipValue)) {
-                return ValidationResult(errorMessage = "Строка \"$line\" должна быть в формате DC:IP.")
-            }
-        }
-
-        val logMaxMbValue = logMaxMbText.trim().toDoubleOrNull()
-            ?: return ValidationResult(
-                errorMessage = "Размер лог-файла должен быть числом."
-            )
-        if (logMaxMbValue <= 0.0) {
-            return ValidationResult(
-                errorMessage = "Размер лог-файла должен быть больше нуля."
-            )
-        }
-
-        val bufferKbValue = bufferKbText.trim().toIntOrNull()
-            ?: return ValidationResult(
-                errorMessage = "Буфер сокета должен быть целым числом."
-            )
-        if (bufferKbValue < 4) {
-            return ValidationResult(
-                errorMessage = "Буфер сокета должен быть не меньше 4 KB."
-            )
-        }
-
-        val poolSizeValue = poolSizeText.trim().toIntOrNull()
-            ?: return ValidationResult(
-                errorMessage = "Размер WS pool должен быть целым числом."
-            )
-        if (poolSizeValue < 0) {
-            return ValidationResult(
-                errorMessage = "Размер WS pool не может быть отрицательным."
-            )
-        }
-
-        return ValidationResult(
-            normalized = NormalizedProxyConfig(
-                host = hostValue,
-                port = portValue,
-                dcIpList = lines,
-                logMaxMb = logMaxMbValue,
-                bufferKb = bufferKbValue,
-                poolSize = poolSizeValue,
-                checkUpdates = checkUpdates,
-                verbose = verbose,
-            )
-        )
-    }
-
-    companion object {
-        const val DEFAULT_HOST = "127.0.0.1"
-        const val DEFAULT_PORT = 1080
-        const val DEFAULT_LOG_MAX_MB = 5.0
-        const val DEFAULT_BUFFER_KB = 256
-        const val DEFAULT_POOL_SIZE = 4
-        val DEFAULT_DC_IP_LINES = listOf(
-            "2:149.154.167.220",
-            "4:149.154.167.220",
-        )
-
-        fun formatDecimal(value: Double): String {
-            return if (value % 1.0 == 0.0) {
-                value.toInt().toString()
-            } else {
-                value.toString()
-            }
-        }
-
-        private fun isIpv4Address(value: String): Boolean {
-            val octets = value.split(".")
-            if (octets.size != 4) {
-                return false
-            }
-
-            return octets.all { octet ->
-                octet.isNotEmpty() &&
-                    octet.length <= 3 &&
-                    octet.all(Char::isDigit) &&
-                    octet.toIntOrNull() in 0..255
-            }
-        }
-    }
-}
-
-data class ValidationResult(
-    val normalized: NormalizedProxyConfig? = null,
-    val errorMessage: String? = null,
-)
-
-data class NormalizedProxyConfig(
-    val host: String,
-    val port: Int,
-    val dcIpList: List<String>,
-    val logMaxMb: Double,
-    val bufferKb: Int,
-    val poolSize: Int,
-    val checkUpdates: Boolean,
-    val verbose: Boolean,
-)

android/app/src/main/java/org/flowseal/tgwsproxy/ProxyForegroundService.kt

@@ -1,395 +0,0 @@
-package org.flowseal.tgwsproxy
-
-import android.app.Notification
-import android.app.NotificationChannel
-import android.app.NotificationManager
-import android.app.PendingIntent
-import android.app.Service
-import android.content.Context
-import android.content.Intent
-import android.os.Build
-import android.os.IBinder
-import androidx.core.app.TaskStackBuilder
-import androidx.core.app.NotificationCompat
-import kotlinx.coroutines.CoroutineScope
-import kotlinx.coroutines.Dispatchers
-import kotlinx.coroutines.Job
-import kotlinx.coroutines.SupervisorJob
-import kotlinx.coroutines.cancel
-import kotlinx.coroutines.delay
-import kotlinx.coroutines.isActive
-import kotlinx.coroutines.launch
-import java.util.Locale
-
-class ProxyForegroundService : Service() {
-    private lateinit var settingsStore: ProxySettingsStore
-    private val serviceScope = CoroutineScope(SupervisorJob() + Dispatchers.IO)
-    private var trafficJob: Job? = null
-    private var lastTrafficSample: TrafficSample? = null
-
-    override fun onCreate() {
-        super.onCreate()
-        settingsStore = ProxySettingsStore(this)
-        createNotificationChannel()
-    }
-
-    override fun onStartCommand(intent: Intent?, flags: Int, startId: Int): Int {
-        return when (intent?.action) {
-            ACTION_STOP -> {
-                ProxyServiceState.clearError()
-                serviceScope.launch {
-                    stopProxyRuntime(removeNotification = true, stopService = true)
-                }
-                START_NOT_STICKY
-            }
-
-            ACTION_RESTART -> {
-                val config = loadValidatedConfig() ?: return START_NOT_STICKY
-                ProxyServiceState.clearError()
-                beginProxyStart(config)
-                serviceScope.launch {
-                    stopRuntimeOnly()
-                    startProxyRuntime(config)
-                }
-                START_STICKY
-            }
-
-            else -> {
-                val config = loadValidatedConfig() ?: return START_NOT_STICKY
-                beginProxyStart(config)
-                serviceScope.launch {
-                    startProxyRuntime(config)
-                }
-                START_STICKY
-            }
-        }
-    }
-
-    override fun onDestroy() {
-        stopTrafficUpdates()
-        serviceScope.cancel()
-        runCatching { PythonProxyBridge.stop(this) }
-        ProxyServiceState.markStopped()
-        super.onDestroy()
-    }
-
-    override fun onBind(intent: Intent?): IBinder? = null
-
-    private fun buildNotification(payload: NotificationPayload): Notification {
-        return NotificationCompat.Builder(this, CHANNEL_ID)
-            .setContentTitle(getString(R.string.notification_title))
-            .setContentText(payload.statusText)
-            .setSubText(payload.endpointText)
-            .setStyle(
-                NotificationCompat.BigTextStyle().bigText(payload.detailsText),
-            )
-            .setSmallIcon(R.drawable.ic_proxy_notification)
-            .setContentIntent(createOpenAppPendingIntent())
-            .addAction(
-                0,
-                getString(R.string.notification_action_stop),
-                createStopPendingIntent(),
-            )
-            .setOngoing(true)
-            .setOnlyAlertOnce(true)
-            .build()
-    }
-
-    private suspend fun startProxyRuntime(config: NormalizedProxyConfig) {
-        val result = runCatching {
-            PythonProxyBridge.start(this, config)
-        }
-
-        result.onSuccess {
-            ProxyServiceState.markStarted(config)
-            lastTrafficSample = null
-            updateNotification(
-                buildNotificationPayload(
-                    config = config,
-                    trafficState = TrafficState(running = true),
-                    statusText = getString(
-                        R.string.notification_running,
-                        config.host,
-                        config.port,
-                    ),
-                ),
-            )
-            startTrafficUpdates(config)
-        }.onFailure { error ->
-            ProxyServiceState.markFailed(
-                error.message ?: getString(R.string.proxy_start_failed_generic),
-            )
-            stopTrafficUpdates()
-            stopForeground(STOP_FOREGROUND_REMOVE)
-            stopSelf()
-        }
-    }
-
-    private fun loadValidatedConfig(): NormalizedProxyConfig? {
-        val config = settingsStore.load().validate().normalized
-        if (config == null) {
-            ProxyServiceState.markFailed(getString(R.string.saved_config_invalid))
-            stopForeground(STOP_FOREGROUND_REMOVE)
-            stopSelf()
-        }
-        return config
-    }
-
-    private fun beginProxyStart(config: NormalizedProxyConfig) {
-        ProxyServiceState.markStarting(config)
-        startForeground(
-            NOTIFICATION_ID,
-            buildNotification(
-                buildNotificationPayload(
-                    config = config,
-                    trafficState = TrafficState(),
-                    statusText = getString(
-                        R.string.notification_starting,
-                        config.host,
-                        config.port,
-                    ),
-                ),
-            ),
-        )
-    }
-
-    private fun stopProxyRuntime(removeNotification: Boolean, stopService: Boolean) {
-        stopRuntimeOnly()
-        ProxyServiceState.markStopped()
-
-        if (removeNotification) {
-            stopForeground(STOP_FOREGROUND_REMOVE)
-        }
-        if (stopService) {
-            stopSelf()
-        }
-    }
-
-    private fun stopRuntimeOnly() {
-        stopTrafficUpdates()
-        runCatching { PythonProxyBridge.stop(this) }
-    }
-
-    private fun updateNotification(payload: NotificationPayload) {
-        val manager = getSystemService(NotificationManager::class.java)
-        manager.notify(NOTIFICATION_ID, buildNotification(payload))
-    }
-
-    private fun buildNotificationPayload(
-        config: NormalizedProxyConfig,
-        trafficState: TrafficState,
-        statusText: String,
-    ): NotificationPayload {
-        val endpointText = getString(R.string.notification_endpoint, config.host, config.port)
-        val detailsText = getString(
-            R.string.notification_details,
-            config.dcIpList.size,
-            formatRate(trafficState.upBytesPerSecond),
-            formatRate(trafficState.downBytesPerSecond),
-            formatBytes(trafficState.totalBytesUp),
-            formatBytes(trafficState.totalBytesDown),
-        )
-        return NotificationPayload(
-            statusText = statusText,
-            endpointText = endpointText,
-            detailsText = detailsText,
-        )
-    }
-
-    private fun startTrafficUpdates(config: NormalizedProxyConfig) {
-        stopTrafficUpdates()
-        trafficJob = serviceScope.launch {
-            while (isActive && ProxyServiceState.isRunning.value) {
-                val trafficState = readTrafficState()
-                if (!trafficState.running) {
-                    ProxyServiceState.markFailed(
-                        trafficState.lastError ?: getString(R.string.proxy_runtime_stopped_unexpectedly),
-                    )
-                    stopForeground(STOP_FOREGROUND_REMOVE)
-                    stopSelf()
-                    break
-                }
-                updateNotification(
-                    buildNotificationPayload(
-                        config = config,
-                        trafficState = trafficState,
-                        statusText = getString(
-                            R.string.notification_running,
-                            config.host,
-                            config.port,
-                        ),
-                    ),
-                )
-                delay(1000)
-            }
-        }
-    }
-
-    private fun stopTrafficUpdates() {
-        trafficJob?.cancel()
-        trafficJob = null
-        lastTrafficSample = null
-    }
-
-    private fun readTrafficState(): TrafficState {
-        val nowMillis = System.currentTimeMillis()
-        val current = PythonProxyBridge.getTrafficStats(this)
-        val previous = lastTrafficSample
-        lastTrafficSample = TrafficSample(
-            bytesUp = current.bytesUp,
-            bytesDown = current.bytesDown,
-            timestampMillis = nowMillis,
-        )
-
-        if (!current.running || previous == null) {
-            return TrafficState(
-                upBytesPerSecond = 0L,
-                downBytesPerSecond = 0L,
-                totalBytesUp = current.bytesUp,
-                totalBytesDown = current.bytesDown,
-                running = current.running,
-                lastError = current.lastError,
-            )
-        }
-
-        val elapsedMillis = (nowMillis - previous.timestampMillis).coerceAtLeast(1L)
-        val upDelta = (current.bytesUp - previous.bytesUp).coerceAtLeast(0L)
-        val downDelta = (current.bytesDown - previous.bytesDown).coerceAtLeast(0L)
-        return TrafficState(
-            upBytesPerSecond = (upDelta * 1000L) / elapsedMillis,
-            downBytesPerSecond = (downDelta * 1000L) / elapsedMillis,
-            totalBytesUp = current.bytesUp,
-            totalBytesDown = current.bytesDown,
-            running = current.running,
-            lastError = current.lastError,
-        )
-    }
-
-    private fun formatRate(bytesPerSecond: Long): String = formatBytes(bytesPerSecond)
-
-    private fun formatBytes(bytes: Long): String {
-        val units = arrayOf("B", "KB", "MB", "GB")
-        var value = bytes.toDouble().coerceAtLeast(0.0)
-        var unitIndex = 0
-
-        while (value >= 1024.0 && unitIndex < units.lastIndex) {
-            value /= 1024.0
-            unitIndex += 1
-        }
-
-        return if (unitIndex == 0) {
-            String.format(Locale.US, "%.0f %s", value, units[unitIndex])
-        } else {
-            String.format(Locale.US, "%.1f %s", value, units[unitIndex])
-        }
-    }
-
-    private fun createOpenAppPendingIntent(): PendingIntent {
-        val launchIntent = packageManager.getLaunchIntentForPackage(packageName)
-            ?.apply {
-                addFlags(
-                    Intent.FLAG_ACTIVITY_NEW_TASK or
-                        Intent.FLAG_ACTIVITY_CLEAR_TOP or
-                        Intent.FLAG_ACTIVITY_SINGLE_TOP,
-                )
-            }
-            ?: Intent(this, MainActivity::class.java).apply {
-                addFlags(
-                    Intent.FLAG_ACTIVITY_NEW_TASK or
-                        Intent.FLAG_ACTIVITY_CLEAR_TOP or
-                        Intent.FLAG_ACTIVITY_SINGLE_TOP,
-                )
-            }
-
-        return TaskStackBuilder.create(this)
-            .addNextIntentWithParentStack(launchIntent)
-            .getPendingIntent(
-                1,
-                PendingIntent.FLAG_UPDATE_CURRENT or PendingIntent.FLAG_IMMUTABLE,
-            )
-            ?: PendingIntent.getActivity(
-                this,
-                1,
-                launchIntent,
-                PendingIntent.FLAG_UPDATE_CURRENT or PendingIntent.FLAG_IMMUTABLE,
-            )
-    }
-
-    private fun createStopPendingIntent(): PendingIntent {
-        val intent = Intent(this, ProxyForegroundService::class.java).apply {
-            action = ACTION_STOP
-        }
-        return PendingIntent.getService(
-            this,
-            2,
-            intent,
-            PendingIntent.FLAG_UPDATE_CURRENT or PendingIntent.FLAG_IMMUTABLE,
-        )
-    }
-
-    private fun createNotificationChannel() {
-        if (Build.VERSION.SDK_INT < Build.VERSION_CODES.O) {
-            return
-        }
-
-        val manager = getSystemService(NotificationManager::class.java)
-        val channel = NotificationChannel(
-            CHANNEL_ID,
-            getString(R.string.notification_channel_name),
-            NotificationManager.IMPORTANCE_LOW,
-        ).apply {
-            description = getString(R.string.notification_channel_description)
-        }
-        manager.createNotificationChannel(channel)
-    }
-
-    companion object {
-        private const val CHANNEL_ID = "proxy_service"
-        private const val NOTIFICATION_ID = 1001
-        private const val ACTION_START = "org.flowseal.tgwsproxy.action.START"
-        private const val ACTION_STOP = "org.flowseal.tgwsproxy.action.STOP"
-        private const val ACTION_RESTART = "org.flowseal.tgwsproxy.action.RESTART"
-
-        fun start(context: Context) {
-            val intent = Intent(context, ProxyForegroundService::class.java).apply {
-                action = ACTION_START
-            }
-            androidx.core.content.ContextCompat.startForegroundService(context, intent)
-        }
-
-        fun stop(context: Context) {
-            val intent = Intent(context, ProxyForegroundService::class.java).apply {
-                action = ACTION_STOP
-            }
-            context.startService(intent)
-        }
-
-        fun restart(context: Context) {
-            val intent = Intent(context, ProxyForegroundService::class.java).apply {
-                action = ACTION_RESTART
-            }
-            androidx.core.content.ContextCompat.startForegroundService(context, intent)
-        }
-    }
-}
-
-private data class NotificationPayload(
-    val statusText: String,
-    val endpointText: String,
-    val detailsText: String,
-)
-
-private data class TrafficSample(
-    val bytesUp: Long,
-    val bytesDown: Long,
-    val timestampMillis: Long,
-)
-
-private data class TrafficState(
-    val upBytesPerSecond: Long = 0L,
-    val downBytesPerSecond: Long = 0L,
-    val totalBytesUp: Long = 0L,
-    val totalBytesDown: Long = 0L,
-    val running: Boolean = false,
-    val lastError: String? = null,
-)

android/app/src/main/java/org/flowseal/tgwsproxy/ProxyServiceState.kt

@@ -1,49 +0,0 @@
-package org.flowseal.tgwsproxy
-
-import kotlinx.coroutines.flow.MutableStateFlow
-import kotlinx.coroutines.flow.StateFlow
-
-object ProxyServiceState {
-    private val _isRunning = MutableStateFlow(false)
-    val isRunning: StateFlow<Boolean> = _isRunning
-
-    private val _isStarting = MutableStateFlow(false)
-    val isStarting: StateFlow<Boolean> = _isStarting
-
-    private val _activeConfig = MutableStateFlow<NormalizedProxyConfig?>(null)
-    val activeConfig: StateFlow<NormalizedProxyConfig?> = _activeConfig
-
-    private val _lastError = MutableStateFlow<String?>(null)
-    val lastError: StateFlow<String?> = _lastError
-
-    fun markStarting(config: NormalizedProxyConfig) {
-        _activeConfig.value = config
-        _isStarting.value = true
-        _isRunning.value = false
-        _lastError.value = null
-    }
-
-    fun markStarted(config: NormalizedProxyConfig) {
-        _activeConfig.value = config
-        _isStarting.value = false
-        _isRunning.value = true
-        _lastError.value = null
-    }
-
-    fun markFailed(message: String) {
-        _activeConfig.value = null
-        _isStarting.value = false
-        _isRunning.value = false
-        _lastError.value = message
-    }
-
-    fun markStopped() {
-        _activeConfig.value = null
-        _isStarting.value = false
-        _isRunning.value = false
-    }
-
-    fun clearError() {
-        _lastError.value = null
-    }
-}

android/app/src/main/java/org/flowseal/tgwsproxy/ProxySettingsStore.kt

@@ -1,59 +0,0 @@
-package org.flowseal.tgwsproxy
-
-import android.content.Context
-
-class ProxySettingsStore(context: Context) {
-    private val preferences = context.getSharedPreferences(PREFS_NAME, Context.MODE_PRIVATE)
-
-    fun load(): ProxyConfig {
-        return ProxyConfig(
-            host = preferences.getString(KEY_HOST, ProxyConfig.DEFAULT_HOST).orEmpty(),
-            portText = preferences.getInt(KEY_PORT, ProxyConfig.DEFAULT_PORT).toString(),
-            dcIpText = preferences.getString(
-                KEY_DC_IP_TEXT,
-                ProxyConfig.DEFAULT_DC_IP_LINES.joinToString("\n"),
-            ).orEmpty(),
-            logMaxMbText = ProxyConfig.formatDecimal(
-                preferences.getFloat(
-                    KEY_LOG_MAX_MB,
-                    ProxyConfig.DEFAULT_LOG_MAX_MB.toFloat(),
-                ).toDouble()
-            ),
-            bufferKbText = preferences.getInt(
-                KEY_BUFFER_KB,
-                ProxyConfig.DEFAULT_BUFFER_KB,
-            ).toString(),
-            poolSizeText = preferences.getInt(
-                KEY_POOL_SIZE,
-                ProxyConfig.DEFAULT_POOL_SIZE,
-            ).toString(),
-            checkUpdates = preferences.getBoolean(KEY_CHECK_UPDATES, false),
-            verbose = preferences.getBoolean(KEY_VERBOSE, false),
-        )
-    }
-
-    fun save(config: NormalizedProxyConfig) {
-        preferences.edit()
-            .putString(KEY_HOST, config.host)
-            .putInt(KEY_PORT, config.port)
-            .putString(KEY_DC_IP_TEXT, config.dcIpList.joinToString("\n"))
-            .putFloat(KEY_LOG_MAX_MB, config.logMaxMb.toFloat())
-            .putInt(KEY_BUFFER_KB, config.bufferKb)
-            .putInt(KEY_POOL_SIZE, config.poolSize)
-            .putBoolean(KEY_CHECK_UPDATES, config.checkUpdates)
-            .putBoolean(KEY_VERBOSE, config.verbose)
-            .apply()
-    }
-
-    companion object {
-        private const val PREFS_NAME = "proxy_settings"
-        private const val KEY_HOST = "host"
-        private const val KEY_PORT = "port"
-        private const val KEY_DC_IP_TEXT = "dc_ip_text"
-        private const val KEY_LOG_MAX_MB = "log_max_mb"
-        private const val KEY_BUFFER_KB = "buf_kb"
-        private const val KEY_POOL_SIZE = "pool_size"
-        private const val KEY_CHECK_UPDATES = "check_updates"
-        private const val KEY_VERBOSE = "verbose"
-    }
-}

android/app/src/main/java/org/flowseal/tgwsproxy/PythonProxyBridge.kt

@@ -1,101 +0,0 @@
-package org.flowseal.tgwsproxy
-
-import android.content.Context
-import com.chaquo.python.Python
-import com.chaquo.python.android.AndroidPlatform
-import java.io.File
-import org.json.JSONObject
-
-object PythonProxyBridge {
-    private const val MODULE_NAME = "android_proxy_bridge"
-    private val pythonStartLock = Any()
-
-    fun start(context: Context, config: NormalizedProxyConfig): String {
-        val module = getModule(context)
-        return module.callAttr(
-            "start_proxy",
-            File(context.filesDir, "tg-ws-proxy").absolutePath,
-            config.host,
-            config.port,
-            config.dcIpList,
-            config.logMaxMb,
-            config.bufferKb,
-            config.poolSize,
-            config.verbose,
-        ).toString()
-    }
-
-    fun stop(context: Context) {
-        if (!Python.isStarted()) {
-            return
-        }
-        getModule(context).callAttr("stop_proxy")
-    }
-
-    fun getTrafficStats(context: Context): ProxyTrafficStats {
-        if (!Python.isStarted()) {
-            return ProxyTrafficStats()
-        }
-
-        val payload = getModule(context).callAttr("get_runtime_stats_json").toString()
-        val json = JSONObject(payload)
-        return ProxyTrafficStats(
-            bytesUp = json.optLong("bytes_up", 0L),
-            bytesDown = json.optLong("bytes_down", 0L),
-            running = json.optBoolean("running", false),
-            lastError = json.optString("last_error").ifBlank { null },
-        )
-    }
-
-    fun getUpdateStatus(context: Context, checkNow: Boolean = false): ProxyUpdateStatus {
-        val payload = getModule(context).callAttr("get_update_status_json", checkNow).toString()
-        val json = JSONObject(payload)
-        return ProxyUpdateStatus(
-            currentVersion = json.optString("current_version").ifBlank { "unknown" },
-            latestVersion = json.optString("latest").ifBlank { null },
-            hasUpdate = json.optBoolean("has_update", false),
-            aheadOfRelease = json.optBoolean("ahead_of_release", false),
-            checked = json.optBoolean("checked", false),
-            htmlUrl = json.optString("html_url").ifBlank { null },
-            error = json.optString("error").ifBlank { null },
-        )
-    }
-
-    private fun getModule(context: Context) =
-        getPython(context.applicationContext).getModule(MODULE_NAME)
-
-    private fun getPython(context: Context): Python {
-        if (Python.isStarted()) {
-            return Python.getInstance()
-        }
-        synchronized(pythonStartLock) {
-            if (!Python.isStarted()) {
-                try {
-                    Python.start(AndroidPlatform(context))
-                } catch (exc: IllegalStateException) {
-                    if (!Python.isStarted()) {
-                        throw exc
-                    }
-                }
-            }
-        }
-        return Python.getInstance()
-    }
-}
-
-data class ProxyTrafficStats(
-    val bytesUp: Long = 0L,
-    val bytesDown: Long = 0L,
-    val running: Boolean = false,
-    val lastError: String? = null,
-)
-
-data class ProxyUpdateStatus(
-    val currentVersion: String = "unknown",
-    val latestVersion: String? = null,
-    val hasUpdate: Boolean = false,
-    val aheadOfRelease: Boolean = false,
-    val checked: Boolean = false,
-    val htmlUrl: String? = null,
-    val error: String? = null,
-)

android/app/src/main/java/org/flowseal/tgwsproxy/TelegramProxyIntent.kt

@@ -1,23 +0,0 @@
-package org.flowseal.tgwsproxy
-
-import android.content.ActivityNotFoundException
-import android.content.Context
-import android.content.Intent
-import android.net.Uri
-
-object TelegramProxyIntent {
-    fun open(context: Context, config: NormalizedProxyConfig): Boolean {
-        val uri = Uri.parse(
-            "tg://socks?server=${Uri.encode(config.host)}&port=${config.port}"
-        )
-        val intent = Intent(Intent.ACTION_VIEW, uri)
-            .addFlags(Intent.FLAG_ACTIVITY_NEW_TASK)
-
-        return try {
-            context.startActivity(intent)
-            true
-        } catch (_: ActivityNotFoundException) {
-            false
-        }
-    }
-}

android/app/src/main/python/android_proxy_bridge.py

@@ -1,160 +0,0 @@
-import os
-import threading
-import time
-import json
-from pathlib import Path
-from typing import Iterable, Optional
-
-from proxy.app_runtime import ProxyAppRuntime
-from proxy import __version__
-import proxy.tg_ws_proxy as tg_ws_proxy
-
-
-RELEASES_PAGE_URL = "https://github.com/Dark-Avery/tg-ws-proxy/releases/latest"
-
-
-_RUNTIME_LOCK = threading.RLock()
-_RUNTIME: Optional[ProxyAppRuntime] = None
-_LAST_ERROR: Optional[str] = None
-
-
-def _remember_error(message: str) -> None:
-    global _LAST_ERROR
-    _LAST_ERROR = message
-
-
-def _normalize_dc_ip_list(dc_ip_list: Iterable[object]) -> list[str]:
-    if dc_ip_list is None:
-        return []
-
-    values: list[object]
-    try:
-        values = list(dc_ip_list)
-    except TypeError:
-        # Chaquopy may expose Kotlin's List<String> as java.util.ArrayList,
-        # which isn't always directly iterable from Python.
-        if hasattr(dc_ip_list, "toArray"):
-            values = list(dc_ip_list.toArray())
-        elif hasattr(dc_ip_list, "size") and hasattr(dc_ip_list, "get"):
-            size = int(dc_ip_list.size())
-            values = [dc_ip_list.get(i) for i in range(size)]
-        else:
-            values = [dc_ip_list]
-
-    return [str(item).strip() for item in values if str(item).strip()]
-
-
-def start_proxy(app_dir: str, host: str, port: int,
-                dc_ip_list: Iterable[object], log_max_mb: float = 5.0,
-                buf_kb: int = 256, pool_size: int = 4,
-                verbose: bool = False) -> str:
-    global _RUNTIME, _LAST_ERROR
-
-    with _RUNTIME_LOCK:
-        if _RUNTIME is not None:
-            _RUNTIME.stop_proxy()
-            _RUNTIME = None
-
-        _LAST_ERROR = None
-        os.environ["TG_WS_PROXY_CRYPTO_BACKEND"] = "python"
-        tg_ws_proxy.reset_stats()
-
-        runtime = ProxyAppRuntime(
-            Path(app_dir),
-            logger_name="tg-ws-android",
-            on_error=_remember_error,
-        )
-        runtime.reset_log_file()
-        runtime.setup_logging(verbose=verbose, log_max_mb=float(log_max_mb))
-
-        config = {
-            "host": host,
-            "port": int(port),
-            "dc_ip": _normalize_dc_ip_list(dc_ip_list),
-            "log_max_mb": float(log_max_mb),
-            "buf_kb": int(buf_kb),
-            "pool_size": int(pool_size),
-            "verbose": bool(verbose),
-        }
-        runtime.save_config(config)
-
-        if not runtime.start_proxy(config):
-            _RUNTIME = None
-            raise RuntimeError(_LAST_ERROR or "Failed to start proxy runtime.")
-
-        _RUNTIME = runtime
-
-    # Give the proxy thread a short warm-up window so immediate bind failures
-    # surface before Kotlin reports the service as running.
-    for _ in range(10):
-        time.sleep(0.1)
-        with _RUNTIME_LOCK:
-            if _LAST_ERROR:
-                runtime.stop_proxy()
-                _RUNTIME = None
-                raise RuntimeError(_LAST_ERROR)
-            if runtime.is_proxy_running():
-                return str(runtime.log_file)
-
-    with _RUNTIME_LOCK:
-        runtime.stop_proxy()
-        _RUNTIME = None
-    raise RuntimeError("Proxy runtime did not become ready in time.")
-
-
-def stop_proxy() -> None:
-    global _RUNTIME, _LAST_ERROR
-
-    with _RUNTIME_LOCK:
-        _LAST_ERROR = None
-        if _RUNTIME is not None:
-            _RUNTIME.stop_proxy()
-            _RUNTIME = None
-
-
-def is_running() -> bool:
-    with _RUNTIME_LOCK:
-        return bool(_RUNTIME and _RUNTIME.is_proxy_running())
-
-
-def get_last_error() -> Optional[str]:
-    return _LAST_ERROR
-
-
-def get_runtime_stats_json() -> str:
-    with _RUNTIME_LOCK:
-        running = bool(_RUNTIME and _RUNTIME.is_proxy_running())
-
-    payload = dict(tg_ws_proxy.get_stats_snapshot())
-    payload["running"] = running
-    payload["last_error"] = _LAST_ERROR
-    return json.dumps(payload)
-
-
-def _load_update_check():
-    from utils import update_check
-    return update_check
-
-
-def get_update_status_json(check_now: bool = False) -> str:
-    payload = {
-        "current_version": __version__,
-        "latest": "",
-        "has_update": False,
-        "ahead_of_release": False,
-        "checked": False,
-        "html_url": RELEASES_PAGE_URL,
-        "error": "",
-    }
-    try:
-        update_check = _load_update_check()
-        if check_now:
-            update_check.run_check(__version__)
-        payload.update(update_check.get_status())
-        payload["current_version"] = __version__
-        payload["latest"] = payload.get("latest") or ""
-        payload["html_url"] = payload.get("html_url") or update_check.RELEASES_PAGE_URL
-        payload["error"] = payload.get("error") or ""
-    except Exception as exc:
-        payload["error"] = str(exc)
-    return json.dumps(payload)

android/app/src/main/res/drawable/ic_proxy_app.xml

@@ -1,13 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<vector xmlns:android="http://schemas.android.com/apk/res/android"
-    android:width="108dp"
-    android:height="108dp"
-    android:viewportWidth="108"
-    android:viewportHeight="108">
-    <path
-        android:fillColor="#1E88E5"
-        android:pathData="M54,10A44,44 0 1,1 10,54A44,44 0 0,1 54,10Z" />
-    <path
-        android:fillColor="#FFFFFF"
-        android:pathData="M33,34h42v10H59v30H49V44H33z" />
-</vector>

android/app/src/main/res/drawable/ic_proxy_notification.xml

@@ -1,13 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<vector xmlns:android="http://schemas.android.com/apk/res/android"
-    android:width="24dp"
-    android:height="24dp"
-    android:viewportWidth="24"
-    android:viewportHeight="24">
-    <path
-        android:fillColor="#FFFFFFFF"
-        android:pathData="M5,4h14v3h-5v12h-4V7H5z" />
-    <path
-        android:fillColor="#FFFFFFFF"
-        android:pathData="M8,20h8v2H8z" />
-</vector>

android/app/src/main/res/layout/activity_log_viewer.xml

@@ -1,94 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<ScrollView xmlns:android="http://schemas.android.com/apk/res/android"
-    xmlns:app="http://schemas.android.com/apk/res-auto"
-    android:layout_width="match_parent"
-    android:layout_height="match_parent"
-    android:fillViewport="true">
-
-    <LinearLayout
-        android:layout_width="match_parent"
-        android:layout_height="wrap_content"
-        android:orientation="vertical"
-        android:padding="20dp">
-
-        <TextView
-            android:layout_width="match_parent"
-            android:layout_height="wrap_content"
-            android:text="@string/logs_title"
-            android:textAppearance="@style/TextAppearance.Material3.HeadlineSmall"
-            android:textStyle="bold" />
-
-        <TextView
-            android:layout_width="match_parent"
-            android:layout_height="wrap_content"
-            android:layout_marginTop="8dp"
-            android:text="@string/logs_subtitle"
-            android:textAppearance="@style/TextAppearance.Material3.BodyMedium" />
-
-        <com.google.android.material.card.MaterialCardView
-            android:layout_width="match_parent"
-            android:layout_height="wrap_content"
-            android:layout_marginTop="20dp"
-            app:cardCornerRadius="20dp">
-
-            <LinearLayout
-                android:layout_width="match_parent"
-                android:layout_height="wrap_content"
-                android:orientation="vertical"
-                android:padding="18dp">
-
-                <TextView
-                    android:layout_width="wrap_content"
-                    android:layout_height="wrap_content"
-                    android:text="@string/logs_path_label"
-                    android:textAppearance="@style/TextAppearance.Material3.LabelLarge" />
-
-                <TextView
-                    android:id="@+id/logPathValue"
-                    android:layout_width="match_parent"
-                    android:layout_height="wrap_content"
-                    android:layout_marginTop="8dp"
-                    android:textAppearance="@style/TextAppearance.Material3.BodySmall" />
-            </LinearLayout>
-        </com.google.android.material.card.MaterialCardView>
-
-        <com.google.android.material.card.MaterialCardView
-            android:layout_width="match_parent"
-            android:layout_height="wrap_content"
-            android:layout_marginTop="16dp"
-            app:cardCornerRadius="20dp">
-
-            <LinearLayout
-                android:layout_width="match_parent"
-                android:layout_height="wrap_content"
-                android:orientation="vertical"
-                android:padding="18dp">
-
-                <TextView
-                    android:id="@+id/logContentValue"
-                    android:layout_width="match_parent"
-                    android:layout_height="wrap_content"
-                    android:fontFamily="monospace"
-                    android:textAppearance="@style/TextAppearance.Material3.BodySmall"
-                    android:textIsSelectable="true" />
-            </LinearLayout>
-        </com.google.android.material.card.MaterialCardView>
-
-        <com.google.android.material.button.MaterialButton
-            android:id="@+id/refreshLogsButton"
-            style="@style/Widget.Material3.Button.OutlinedButton"
-            android:layout_width="match_parent"
-            android:layout_height="wrap_content"
-            android:layout_marginTop="16dp"
-            android:text="@string/refresh_logs_button" />
-
-        <com.google.android.material.button.MaterialButton
-            android:id="@+id/closeLogsButton"
-            style="@style/Widget.Material3.Button.OutlinedButton"
-            android:layout_width="match_parent"
-            android:layout_height="wrap_content"
-            android:layout_marginTop="12dp"
-            android:text="@string/close_logs_button" />
-
-    </LinearLayout>
-</ScrollView>

android/app/src/main/res/layout/activity_main.xml

@@ -1,410 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<ScrollView xmlns:android="http://schemas.android.com/apk/res/android"
-    xmlns:app="http://schemas.android.com/apk/res-auto"
-    android:layout_width="match_parent"
-    android:layout_height="match_parent"
-    android:fillViewport="true">
-
-    <LinearLayout
-        android:layout_width="match_parent"
-        android:layout_height="wrap_content"
-        android:orientation="vertical"
-        android:padding="20dp">
-
-        <TextView
-            android:id="@+id/titleText"
-            android:layout_width="match_parent"
-            android:layout_height="wrap_content"
-            android:text="@string/app_name"
-            android:textAppearance="@style/TextAppearance.Material3.HeadlineSmall"
-            android:textStyle="bold" />
-
-        <TextView
-            android:id="@+id/subtitleText"
-            android:layout_width="match_parent"
-            android:layout_height="wrap_content"
-            android:layout_marginTop="8dp"
-            android:text="@string/subtitle"
-            android:textAppearance="@style/TextAppearance.Material3.BodyMedium" />
-
-        <com.google.android.material.card.MaterialCardView
-            android:layout_width="match_parent"
-            android:layout_height="wrap_content"
-            android:layout_marginTop="20dp"
-            app:cardCornerRadius="20dp">
-
-            <LinearLayout
-                android:layout_width="match_parent"
-                android:layout_height="wrap_content"
-                android:orientation="vertical"
-                android:padding="18dp">
-
-                <TextView
-                    android:layout_width="wrap_content"
-                    android:layout_height="wrap_content"
-                    android:text="@string/status_label"
-                    android:textAppearance="@style/TextAppearance.Material3.LabelLarge" />
-
-                <TextView
-                    android:id="@+id/statusValue"
-                    android:layout_width="wrap_content"
-                    android:layout_height="wrap_content"
-                    android:layout_marginTop="6dp"
-                    android:text="@string/status_stopped"
-                    android:textAppearance="@style/TextAppearance.Material3.TitleMedium"
-                    android:textStyle="bold" />
-
-                <TextView
-                    android:id="@+id/serviceHint"
-                    android:layout_width="match_parent"
-                    android:layout_height="wrap_content"
-                    android:layout_marginTop="10dp"
-                    android:text="@string/service_hint_idle"
-                    android:textAppearance="@style/TextAppearance.Material3.BodyMedium" />
-            </LinearLayout>
-        </com.google.android.material.card.MaterialCardView>
-
-        <com.google.android.material.card.MaterialCardView
-            android:layout_width="match_parent"
-            android:layout_height="wrap_content"
-            android:layout_marginTop="16dp"
-            android:id="@+id/lastErrorCard"
-            android:visibility="gone"
-            app:cardCornerRadius="20dp">
-
-            <LinearLayout
-                android:layout_width="match_parent"
-                android:layout_height="wrap_content"
-                android:orientation="vertical"
-                android:padding="18dp">
-
-                <TextView
-                    android:layout_width="wrap_content"
-                    android:layout_height="wrap_content"
-                    android:text="@string/last_error_label"
-                    android:textAppearance="@style/TextAppearance.Material3.LabelLarge"
-                    android:textColor="?attr/colorError" />
-
-                <TextView
-                    android:id="@+id/lastErrorValue"
-                    android:layout_width="match_parent"
-                    android:layout_height="wrap_content"
-                    android:layout_marginTop="8dp"
-                    android:textAppearance="@style/TextAppearance.Material3.BodyMedium"
-                    android:textColor="?attr/colorError" />
-            </LinearLayout>
-        </com.google.android.material.card.MaterialCardView>
-
-        <com.google.android.material.card.MaterialCardView
-            android:layout_width="match_parent"
-            android:layout_height="wrap_content"
-            android:layout_marginTop="16dp"
-            app:cardCornerRadius="20dp">
-
-            <LinearLayout
-                android:layout_width="match_parent"
-                android:layout_height="wrap_content"
-                android:orientation="vertical"
-                android:padding="18dp">
-
-                <TextView
-                    android:layout_width="wrap_content"
-                    android:layout_height="wrap_content"
-                    android:text="@string/updates_label"
-                    android:textAppearance="@style/TextAppearance.Material3.LabelLarge" />
-
-                <TextView
-                    android:id="@+id/currentVersionValue"
-                    android:layout_width="wrap_content"
-                    android:layout_height="wrap_content"
-                    android:layout_marginTop="6dp"
-                    android:textAppearance="@style/TextAppearance.Material3.BodySmall" />
-
-                <com.google.android.material.materialswitch.MaterialSwitch
-                    android:id="@+id/checkUpdatesSwitch"
-                    android:layout_width="match_parent"
-                    android:layout_height="wrap_content"
-                    android:layout_marginTop="14dp"
-                    android:text="@string/updates_check_label" />
-
-                <TextView
-                    android:id="@+id/updateStatusValue"
-                    android:layout_width="match_parent"
-                    android:layout_height="wrap_content"
-                    android:layout_marginTop="8dp"
-                    android:text="@string/updates_status_initial"
-                    android:textAppearance="@style/TextAppearance.Material3.BodyMedium" />
-
-                <com.google.android.material.button.MaterialButton
-                    android:id="@+id/openReleasePageButton"
-                    style="@style/Widget.Material3.Button.OutlinedButton"
-                    android:layout_width="match_parent"
-                    android:layout_height="wrap_content"
-                    android:layout_marginTop="14dp"
-                    android:text="@string/updates_open_release_button" />
-            </LinearLayout>
-        </com.google.android.material.card.MaterialCardView>
-
-        <com.google.android.material.card.MaterialCardView
-            android:layout_width="match_parent"
-            android:layout_height="wrap_content"
-            android:layout_marginTop="16dp"
-            app:cardCornerRadius="20dp">
-
-            <LinearLayout
-                android:layout_width="match_parent"
-                android:layout_height="wrap_content"
-                android:orientation="vertical"
-                android:padding="18dp">
-
-                <TextView
-                    android:layout_width="wrap_content"
-                    android:layout_height="wrap_content"
-                    android:text="@string/system_status_label"
-                    android:textAppearance="@style/TextAppearance.Material3.LabelLarge" />
-
-                <TextView
-                    android:id="@+id/systemStatusValue"
-                    android:layout_width="wrap_content"
-                    android:layout_height="wrap_content"
-                    android:layout_marginTop="6dp"
-                    android:text="@string/system_status_attention"
-                    android:textAppearance="@style/TextAppearance.Material3.TitleMedium"
-                    android:textStyle="bold" />
-
-                <TextView
-                    android:id="@+id/systemStatusHint"
-                    android:layout_width="match_parent"
-                    android:layout_height="wrap_content"
-                    android:layout_marginTop="10dp"
-                    android:textAppearance="@style/TextAppearance.Material3.BodyMedium" />
-
-                <com.google.android.material.button.MaterialButton
-                    android:id="@+id/disableBatteryOptimizationButton"
-                    style="@style/Widget.Material3.Button.OutlinedButton"
-                    android:layout_width="match_parent"
-                    android:layout_height="wrap_content"
-                    android:layout_marginTop="14dp"
-                    android:text="@string/disable_battery_optimization_button" />
-
-                <com.google.android.material.button.MaterialButton
-                    android:id="@+id/openAppSettingsButton"
-                    style="@style/Widget.Material3.Button.OutlinedButton"
-                    android:layout_width="match_parent"
-                    android:layout_height="wrap_content"
-                    android:layout_marginTop="12dp"
-                    android:text="@string/open_app_settings_button" />
-            </LinearLayout>
-        </com.google.android.material.card.MaterialCardView>
-
-        <com.google.android.material.card.MaterialCardView
-            android:layout_width="match_parent"
-            android:layout_height="wrap_content"
-            android:layout_marginTop="20dp"
-            app:cardCornerRadius="20dp">
-
-            <LinearLayout
-                android:layout_width="match_parent"
-                android:layout_height="wrap_content"
-                android:orientation="vertical"
-                android:padding="18dp">
-
-                <TextView
-                    android:layout_width="wrap_content"
-                    android:layout_height="wrap_content"
-                    android:text="@string/endpoint_section_label"
-                    android:textAppearance="@style/TextAppearance.Material3.LabelLarge" />
-
-                <com.google.android.material.textfield.TextInputLayout
-                    android:layout_width="match_parent"
-                    android:layout_height="wrap_content"
-                    android:layout_marginTop="14dp"
-                    android:hint="@string/host_hint">
-
-                    <com.google.android.material.textfield.TextInputEditText
-                        android:id="@+id/hostInput"
-                        android:layout_width="match_parent"
-                        android:layout_height="wrap_content"
-                        android:inputType="text"
-                        android:maxLines="1" />
-                </com.google.android.material.textfield.TextInputLayout>
-
-                <com.google.android.material.textfield.TextInputLayout
-                    android:layout_width="match_parent"
-                    android:layout_height="wrap_content"
-                    android:layout_marginTop="16dp"
-                    android:hint="@string/port_hint">
-
-                    <com.google.android.material.textfield.TextInputEditText
-                        android:id="@+id/portInput"
-                        android:layout_width="match_parent"
-                        android:layout_height="wrap_content"
-                        android:inputType="number"
-                        android:maxLines="1" />
-                </com.google.android.material.textfield.TextInputLayout>
-
-                <com.google.android.material.textfield.TextInputLayout
-                    android:layout_width="match_parent"
-                    android:layout_height="wrap_content"
-                    android:layout_marginTop="16dp"
-                    android:hint="@string/dc_ip_hint">
-
-                    <com.google.android.material.textfield.TextInputEditText
-                        android:id="@+id/dcIpInput"
-                        android:layout_width="match_parent"
-                        android:layout_height="140dp"
-                        android:gravity="top|start"
-                        android:inputType="textMultiLine"
-                        android:minLines="5" />
-                </com.google.android.material.textfield.TextInputLayout>
-            </LinearLayout>
-        </com.google.android.material.card.MaterialCardView>
-
-        <com.google.android.material.card.MaterialCardView
-            android:layout_width="match_parent"
-            android:layout_height="wrap_content"
-            android:layout_marginTop="16dp"
-            app:cardCornerRadius="20dp">
-
-            <LinearLayout
-                android:layout_width="match_parent"
-                android:layout_height="wrap_content"
-                android:orientation="vertical"
-                android:padding="18dp">
-
-                <TextView
-                    android:layout_width="wrap_content"
-                    android:layout_height="wrap_content"
-                    android:text="@string/advanced_section_label"
-                    android:textAppearance="@style/TextAppearance.Material3.LabelLarge" />
-
-                <com.google.android.material.materialswitch.MaterialSwitch
-                    android:id="@+id/verboseSwitch"
-                    android:layout_width="match_parent"
-                    android:layout_height="wrap_content"
-                    android:layout_marginTop="14dp"
-                    android:text="@string/verbose_label" />
-
-                <com.google.android.material.textfield.TextInputLayout
-                    android:layout_width="match_parent"
-                    android:layout_height="wrap_content"
-                    android:layout_marginTop="16dp"
-                    android:hint="@string/log_max_mb_hint">
-
-                    <com.google.android.material.textfield.TextInputEditText
-                        android:id="@+id/logMaxMbInput"
-                        android:layout_width="match_parent"
-                        android:layout_height="wrap_content"
-                        android:inputType="numberDecimal"
-                        android:maxLines="1" />
-                </com.google.android.material.textfield.TextInputLayout>
-
-                <com.google.android.material.textfield.TextInputLayout
-                    android:layout_width="match_parent"
-                    android:layout_height="wrap_content"
-                    android:layout_marginTop="16dp"
-                    android:hint="@string/buffer_kb_hint">
-
-                    <com.google.android.material.textfield.TextInputEditText
-                        android:id="@+id/bufferKbInput"
-                        android:layout_width="match_parent"
-                        android:layout_height="wrap_content"
-                        android:inputType="number"
-                        android:maxLines="1" />
-                </com.google.android.material.textfield.TextInputLayout>
-
-                <com.google.android.material.textfield.TextInputLayout
-                    android:layout_width="match_parent"
-                    android:layout_height="wrap_content"
-                    android:layout_marginTop="16dp"
-                    android:hint="@string/pool_size_hint">
-
-                    <com.google.android.material.textfield.TextInputEditText
-                        android:id="@+id/poolSizeInput"
-                        android:layout_width="match_parent"
-                        android:layout_height="wrap_content"
-                        android:inputType="number"
-                        android:maxLines="1" />
-                </com.google.android.material.textfield.TextInputLayout>
-            </LinearLayout>
-        </com.google.android.material.card.MaterialCardView>
-
-        <TextView
-            android:id="@+id/errorText"
-            android:layout_width="match_parent"
-            android:layout_height="wrap_content"
-            android:layout_marginTop="12dp"
-            android:textAppearance="@style/TextAppearance.Material3.BodyMedium"
-            android:textColor="?attr/colorError"
-            android:visibility="gone" />
-
-        <com.google.android.material.card.MaterialCardView
-            android:layout_width="match_parent"
-            android:layout_height="wrap_content"
-            android:layout_marginTop="12dp"
-            app:cardCornerRadius="20dp">
-
-            <LinearLayout
-                android:layout_width="match_parent"
-                android:layout_height="wrap_content"
-                android:orientation="vertical"
-                android:padding="18dp">
-
-                <TextView
-                    android:layout_width="wrap_content"
-                    android:layout_height="wrap_content"
-                    android:text="@string/actions_section_label"
-                    android:textAppearance="@style/TextAppearance.Material3.LabelLarge" />
-
-                <com.google.android.material.button.MaterialButton
-                    android:id="@+id/saveButton"
-                    style="@style/Widget.Material3.Button.OutlinedButton"
-                    android:layout_width="match_parent"
-                    android:layout_height="wrap_content"
-                    android:layout_marginTop="14dp"
-                    android:text="@string/save_button" />
-
-                <com.google.android.material.button.MaterialButton
-                    android:id="@+id/startButton"
-                    android:layout_width="match_parent"
-                    android:layout_height="wrap_content"
-                    android:layout_marginTop="12dp"
-                    android:text="@string/start_button" />
-
-                <com.google.android.material.button.MaterialButton
-                    android:id="@+id/stopButton"
-                    style="@style/Widget.Material3.Button.OutlinedButton"
-                    android:layout_width="match_parent"
-                    android:layout_height="wrap_content"
-                    android:layout_marginTop="12dp"
-                    android:enabled="false"
-                    android:text="@string/stop_button" />
-
-                <com.google.android.material.button.MaterialButton
-                    android:id="@+id/restartButton"
-                    style="@style/Widget.Material3.Button.OutlinedButton"
-                    android:layout_width="match_parent"
-                    android:layout_height="wrap_content"
-                    android:layout_marginTop="12dp"
-                    android:text="@string/restart_button" />
-
-                <com.google.android.material.button.MaterialButton
-                    android:id="@+id/openTelegramButton"
-                    style="@style/Widget.Material3.Button.OutlinedButton"
-                    android:layout_width="match_parent"
-                    android:layout_height="wrap_content"
-                    android:layout_marginTop="12dp"
-                    android:text="@string/open_telegram_button" />
-
-                <com.google.android.material.button.MaterialButton
-                    android:id="@+id/openLogsButton"
-                    style="@style/Widget.Material3.Button.OutlinedButton"
-                    android:layout_width="match_parent"
-                    android:layout_height="wrap_content"
-                    android:layout_marginTop="12dp"
-                    android:text="@string/open_logs_button" />
-            </LinearLayout>
-        </com.google.android.material.card.MaterialCardView>
-
-    </LinearLayout>
-</ScrollView>

android/app/src/main/res/values/colors.xml

@@ -1,7 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<resources>
-    <color name="proxy_blue">#1E88E5</color>
-    <color name="proxy_navy">#0B1F33</color>
-    <color name="proxy_surface">#F4F8FC</color>
-    <color name="proxy_white">#FFFFFF</color>
-</resources>

android/app/src/main/res/values/strings.xml

@@ -1,74 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<resources>
-    <string name="app_name">TG WS Proxy</string>
-    <string name="subtitle">Android app for the local Telegram SOCKS5 proxy.</string>
-    <string name="status_label">Foreground service</string>
-    <string name="status_starting">Starting</string>
-    <string name="status_running">Running</string>
-    <string name="status_stopped">Stopped</string>
-    <string name="service_hint_idle">Configure the proxy settings, then start the foreground service.</string>
-    <string name="service_hint_starting">Starting embedded Python proxy for %1$s:%2$d.</string>
-    <string name="service_hint_running">Foreground service active for %1$s:%2$d.</string>
-    <string name="system_status_label">Android background limits</string>
-    <string name="system_status_ready">Ready</string>
-    <string name="system_status_attention">Needs attention</string>
-    <string name="system_check_battery_ignored">Battery optimization: disabled for this app.</string>
-    <string name="system_check_battery_active">Battery optimization: still enabled, Android may stop the proxy in background.</string>
-    <string name="system_check_background_ok">Background restriction: not detected.</string>
-    <string name="system_check_background_restricted">Background restriction: enabled, Android may block long-running work.</string>
-    <string name="system_check_oem_note">Some phones also require manual vendor settings such as Autostart, Lock in recents, or Unrestricted battery mode.</string>
-    <string name="endpoint_section_label">Proxy endpoint</string>
-    <string name="advanced_section_label">Advanced</string>
-    <string name="actions_section_label">Actions</string>
-    <string name="updates_label">Updates</string>
-    <string name="updates_current_version_format">v%1$s</string>
-    <string name="updates_check_label">Check for updates on launch</string>
-    <string name="updates_status_initial">Checking GitHub release…</string>
-    <string name="updates_status_idle">Not checked yet</string>
-    <string name="updates_status_disabled">Automatic update checks are disabled.</string>
-    <string name="updates_status_latest">Installed version %1$s matches the latest GitHub release.</string>
-    <string name="updates_status_newer">Installed version %1$s is newer than the latest GitHub release.</string>
-    <string name="updates_status_available">Version %1$s is available on GitHub (installed: %2$s).</string>
-    <string name="updates_status_error">Update check failed: %1$s</string>
-    <string name="updates_open_release_button">Open Release Page</string>
-    <string name="host_hint">Proxy host</string>
-    <string name="port_hint">Proxy port</string>
-    <string name="dc_ip_hint">DC to IP mappings (one DC:IP per line)</string>
-    <string name="log_max_mb_hint">Max log size before rotation (MB)</string>
-    <string name="buffer_kb_hint">Socket buffer size (KB)</string>
-    <string name="pool_size_hint">WS pool size per DC</string>
-    <string name="verbose_label">Verbose logging</string>
-    <string name="save_button">Save Settings</string>
-    <string name="start_button">Start Service</string>
-    <string name="stop_button">Stop Service</string>
-    <string name="restart_button">Restart Proxy</string>
-    <string name="open_telegram_button">Open in Telegram</string>
-    <string name="open_logs_button">Open Logs</string>
-    <string name="disable_battery_optimization_button">Disable Battery Optimization</string>
-    <string name="open_app_settings_button">Open App Settings</string>
-    <string name="last_error_label">Last service error</string>
-    <string name="release_page_open_failed">Failed to open release page.</string>
-    <string name="settings_saved">Settings saved</string>
-    <string name="service_start_requested">Foreground service start requested</string>
-    <string name="service_restart_requested">Foreground service restart requested</string>
-    <string name="telegram_not_found">Telegram app was not found for tg://socks.</string>
-    <string name="notification_title">TG WS Proxy</string>
-    <string name="notification_channel_name">Proxy service</string>
-    <string name="notification_channel_description">Keeps the Telegram proxy service alive in the foreground.</string>
-    <string name="notification_starting">SOCKS5 %1$s:%2$d • starting embedded Python</string>
-    <string name="notification_running">SOCKS5 %1$s:%2$d • proxy active</string>
-    <string name="notification_endpoint">%1$s:%2$d</string>
-    <string name="notification_details">DC mappings: %1$d\nTraffic: ↑ %2$s/s ↓ %3$s/s\nTransferred: ↑ %4$s ↓ %5$s</string>
-    <string name="notification_action_stop">Stop</string>
-    <string name="saved_config_invalid">Saved proxy settings are invalid.</string>
-    <string name="proxy_start_failed_generic">Failed to start embedded Python proxy.</string>
-    <string name="proxy_runtime_stopped_unexpectedly">Proxy runtime stopped unexpectedly.</string>
-    <string name="logs_title">Proxy Logs</string>
-    <string name="logs_subtitle">Shows the latest lines from the embedded Python proxy log.</string>
-    <string name="logs_path_label">Log file</string>
-    <string name="refresh_logs_button">Refresh Logs</string>
-    <string name="close_logs_button">Close</string>
-    <string name="logs_empty">The log file is empty or has not been created yet.</string>
-    <string name="logs_read_failed">Failed to read log file: %1$s</string>
-    <string name="logs_truncated_prefix">Showing the last part of the log file.</string>
-</resources>

android/app/src/main/res/values/themes.xml

@@ -1,11 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<resources xmlns:tools="http://schemas.android.com/tools">
-    <style name="Theme.TgWsProxy" parent="Theme.Material3.Light.NoActionBar">
-        <item name="colorPrimary">@color/proxy_blue</item>
-        <item name="colorSecondary">@color/proxy_navy</item>
-        <item name="android:statusBarColor">@color/proxy_navy</item>
-        <item name="android:navigationBarColor">@color/proxy_white</item>
-        <item name="colorSurface">@color/proxy_surface</item>
-        <item name="android:windowLightStatusBar" tools:targetApi="m">false</item>
-    </style>
-</resources>

android/build-local-debug.sh

@@ -1,156 +0,0 @@
-#!/usr/bin/env bash
-
-set -euo pipefail
-
-ROOT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
-
-if [[ -z "${GRADLE_USER_HOME:-}" ]]; then
-  if [[ -d "$HOME/.gradle" && -w "$HOME/.gradle" ]]; then
-    export GRADLE_USER_HOME="$HOME/.gradle"
-  else
-    export GRADLE_USER_HOME="$ROOT_DIR/.gradle-local"
-  fi
-fi
-
-mkdir -p "$GRADLE_USER_HOME"
-
-if [[ -d "$HOME/.local/jdk" ]]; then
-  export JAVA_HOME="$HOME/.local/jdk"
-fi
-
-if [[ -d "$HOME/android-sdk" ]]; then
-  export ANDROID_SDK_ROOT="$HOME/android-sdk"
-fi
-
-if [[ -n "${JAVA_HOME:-}" ]]; then
-  export PATH="$JAVA_HOME/bin:$PATH"
-fi
-
-if [[ -n "${ANDROID_SDK_ROOT:-}" ]]; then
-  export PATH="$ANDROID_SDK_ROOT/cmdline-tools/latest/bin:$ANDROID_SDK_ROOT/platform-tools:$PATH"
-fi
-
-if [[ -d "$HOME/.local/gradle/gradle-8.7/bin" ]]; then
-  export PATH="$HOME/.local/gradle/gradle-8.7/bin:$PATH"
-fi
-
-unset HTTP_PROXY HTTPS_PROXY ALL_PROXY http_proxy https_proxy all_proxy
-
-GRADLE_BIN="gradle"
-if [[ -x "$ROOT_DIR/gradlew" ]]; then
-  GRADLE_BIN="$ROOT_DIR/gradlew"
-fi
-
-ATTEMPTS="${ATTEMPTS:-5}"
-SLEEP_SECONDS="${SLEEP_SECONDS:-15}"
-TASK="${1:-assembleStandardDebug}"
-LOCAL_CHAQUOPY_REPO="${LOCAL_CHAQUOPY_REPO:-$ROOT_DIR/.m2-chaquopy}"
-CHAQUOPY_MAVEN_BASE="${CHAQUOPY_MAVEN_BASE:-https://repo.maven.apache.org/maven2}"
-
-task_uses_legacy32() {
-  [[ "$TASK" =~ [Ll]egacy32 ]]
-}
-
-task_uses_standard() {
-  if [[ "$TASK" =~ [Ss]tandard ]]; then
-    return 0
-  fi
-
-  if task_uses_legacy32; then
-    return 1
-  fi
-
-  return 0
-}
-
-prefetch_artifact() {
-  local relative_path="$1"
-  local destination="$LOCAL_CHAQUOPY_REPO/$relative_path"
-
-  if [[ -f "$destination" ]]; then
-    return 0
-  fi
-
-  mkdir -p "$(dirname "$destination")"
-  echo "Prefetching $relative_path"
-  curl \
-    --fail \
-    --location \
-    --retry 8 \
-    --retry-all-errors \
-    --continue-at - \
-    --connect-timeout 15 \
-    --speed-limit 1024 \
-    --speed-time 20 \
-    --max-time 90 \
-    --output "$destination" \
-    "$CHAQUOPY_MAVEN_BASE/$relative_path"
-}
-
-prefetch_chaquopy_runtime() {
-  local artifacts=(
-    "com/chaquo/python/runtime/chaquopy_java/17.0.0/chaquopy_java-17.0.0.pom"
-    "com/chaquo/python/runtime/chaquopy_java/17.0.0/chaquopy_java-17.0.0.jar"
-    "com/chaquo/python/runtime/libchaquopy_java/17.0.0/libchaquopy_java-17.0.0.pom"
-  )
-
-  if task_uses_standard; then
-    artifacts+=(
-      "com/chaquo/python/runtime/libchaquopy_java/17.0.0/libchaquopy_java-17.0.0-3.12-arm64-v8a.so"
-      "com/chaquo/python/runtime/libchaquopy_java/17.0.0/libchaquopy_java-17.0.0-3.12-x86_64.so"
-      "com/chaquo/python/target/3.12.12-0/target-3.12.12-0.pom"
-      "com/chaquo/python/target/3.12.12-0/target-3.12.12-0-arm64-v8a.zip"
-      "com/chaquo/python/target/3.12.12-0/target-3.12.12-0-stdlib-pyc.zip"
-      "com/chaquo/python/target/3.12.12-0/target-3.12.12-0-stdlib.zip"
-      "com/chaquo/python/target/3.12.12-0/target-3.12.12-0-x86_64.zip"
-    )
-  fi
-
-  if task_uses_legacy32; then
-    artifacts+=(
-      "com/chaquo/python/runtime/libchaquopy_java/17.0.0/libchaquopy_java-17.0.0-3.11-armeabi-v7a.so"
-      "com/chaquo/python/target/3.11.10-0/target-3.11.10-0.pom"
-      "com/chaquo/python/target/3.11.10-0/target-3.11.10-0-armeabi-v7a.zip"
-      "com/chaquo/python/target/3.11.10-0/target-3.11.10-0-stdlib-pyc.zip"
-      "com/chaquo/python/target/3.11.10-0/target-3.11.10-0-stdlib.zip"
-    )
-  fi
-
-  for artifact in "${artifacts[@]}"; do
-    prefetch_artifact "$artifact"
-  done
-}
-
-cleanup_stale_build_state() {
-  local stale_dirs=(
-    "$ROOT_DIR/app/build/python/env"
-    "$ROOT_DIR/app/build/intermediates/project_dex_archive"
-    "$ROOT_DIR/app/build/intermediates/desugar_graph"
-    "$ROOT_DIR/app/build/tmp/kotlin-classes"
-    "$ROOT_DIR/app/build/snapshot/kotlin"
-  )
-
-  for stale_dir in "${stale_dirs[@]}"; do
-    if [[ -d "$stale_dir" ]]; then
-      rm -rf "$stale_dir"
-    fi
-  done
-}
-
-prefetch_chaquopy_runtime
-
-for attempt in $(seq 1 "$ATTEMPTS"); do
-  echo "==> Android build attempt $attempt/$ATTEMPTS ($TASK)"
-  if "$GRADLE_BIN" --no-daemon --console=plain "$TASK"; then
-    exit 0
-  fi
-
-  if [[ "$attempt" -lt "$ATTEMPTS" ]]; then
-    cleanup_stale_build_state
-    echo "Build failed, retrying in ${SLEEP_SECONDS}s..."
-    sleep "$SLEEP_SECONDS"
-  fi
-done
-
-echo "Android build failed after $ATTEMPTS attempts."
-exit 1

android/build.gradle.kts

@@ -1,5 +0,0 @@
-plugins {
-    id("com.android.application") version "8.5.2" apply false
-    id("com.chaquo.python") version "17.0.0" apply false
-    id("org.jetbrains.kotlin.android") version "1.9.24" apply false
-}

android/gradle.properties

@@ -1,6 +0,0 @@
-org.gradle.jvmargs=-Xmx2048m -Dfile.encoding=UTF-8
-android.useAndroidX=true
-android.nonTransitiveRClass=true
-kotlin.code.style=official
-systemProp.org.gradle.internal.http.connectionTimeout=120000
-systemProp.org.gradle.internal.http.socketTimeout=120000

android/gradle/wrapper/gradle-wrapper.properties

@@ -1,7 +0,0 @@
-distributionBase=GRADLE_USER_HOME
-distributionPath=wrapper/dists
-distributionUrl=https\://services.gradle.org/distributions/gradle-8.7-bin.zip
-networkTimeout=120000
-validateDistributionUrl=true
-zipStoreBase=GRADLE_USER_HOME
-zipStorePath=wrapper/dists

android/gradlew

@@ -1,249 +0,0 @@
-#!/bin/sh
-
-#
-# Copyright © 2015-2021 the original authors.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#      https://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-#
-
-##############################################################################
-#
-#   Gradle start up script for POSIX generated by Gradle.
-#
-#   Important for running:
-#
-#   (1) You need a POSIX-compliant shell to run this script. If your /bin/sh is
-#       noncompliant, but you have some other compliant shell such as ksh or
-#       bash, then to run this script, type that shell name before the whole
-#       command line, like:
-#
-#           ksh Gradle
-#
-#       Busybox and similar reduced shells will NOT work, because this script
-#       requires all of these POSIX shell features:
-#         * functions;
-#         * expansions «$var», «${var}», «${var:-default}», «${var+SET}»,
-#           «${var#prefix}», «${var%suffix}», and «$( cmd )»;
-#         * compound commands having a testable exit status, especially «case»;
-#         * various built-in commands including «command», «set», and «ulimit».
-#
-#   Important for patching:
-#
-#   (2) This script targets any POSIX shell, so it avoids extensions provided
-#       by Bash, Ksh, etc; in particular arrays are avoided.
-#
-#       The "traditional" practice of packing multiple parameters into a
-#       space-separated string is a well documented source of bugs and security
-#       problems, so this is (mostly) avoided, by progressively accumulating
-#       options in "$@", and eventually passing that to Java.
-#
-#       Where the inherited environment variables (DEFAULT_JVM_OPTS, JAVA_OPTS,
-#       and GRADLE_OPTS) rely on word-splitting, this is performed explicitly;
-#       see the in-line comments for details.
-#
-#       There are tweaks for specific operating systems such as AIX, CygWin,
-#       Darwin, MinGW, and NonStop.
-#
-#   (3) This script is generated from the Groovy template
-#       https://github.com/gradle/gradle/blob/HEAD/subprojects/plugins/src/main/resources/org/gradle/api/internal/plugins/unixStartScript.txt
-#       within the Gradle project.
-#
-#       You can find Gradle at https://github.com/gradle/gradle/.
-#
-##############################################################################
-
-# Attempt to set APP_HOME
-
-# Resolve links: $0 may be a link
-app_path=$0
-
-# Need this for daisy-chained symlinks.
-while
-    APP_HOME=${app_path%"${app_path##*/}"}  # leaves a trailing /; empty if no leading path
-    [ -h "$app_path" ]
-do
-    ls=$( ls -ld "$app_path" )
-    link=${ls#*' -> '}
-    case $link in             #(
-      /*)   app_path=$link ;; #(
-      *)    app_path=$APP_HOME$link ;;
-    esac
-done
-
-# This is normally unused
-# shellcheck disable=SC2034
-APP_BASE_NAME=${0##*/}
-# Discard cd standard output in case $CDPATH is set (https://github.com/gradle/gradle/issues/25036)
-APP_HOME=$( cd "${APP_HOME:-./}" > /dev/null && pwd -P ) || exit
-
-# Use the maximum available, or set MAX_FD != -1 to use that value.
-MAX_FD=maximum
-
-warn () {
-    echo "$*"
-} >&2
-
-die () {
-    echo
-    echo "$*"
-    echo
-    exit 1
-} >&2
-
-# OS specific support (must be 'true' or 'false').
-cygwin=false
-msys=false
-darwin=false
-nonstop=false
-case "$( uname )" in                #(
-  CYGWIN* )         cygwin=true  ;; #(
-  Darwin* )         darwin=true  ;; #(
-  MSYS* | MINGW* )  msys=true    ;; #(
-  NONSTOP* )        nonstop=true ;;
-esac
-
-CLASSPATH=$APP_HOME/gradle/wrapper/gradle-wrapper.jar
-
-
-# Determine the Java command to use to start the JVM.
-if [ -n "$JAVA_HOME" ] ; then
-    if [ -x "$JAVA_HOME/jre/sh/java" ] ; then
-        # IBM's JDK on AIX uses strange locations for the executables
-        JAVACMD=$JAVA_HOME/jre/sh/java
-    else
-        JAVACMD=$JAVA_HOME/bin/java
-    fi
-    if [ ! -x "$JAVACMD" ] ; then
-        die "ERROR: JAVA_HOME is set to an invalid directory: $JAVA_HOME
-
-Please set the JAVA_HOME variable in your environment to match the
-location of your Java installation."
-    fi
-else
-    JAVACMD=java
-    if ! command -v java >/dev/null 2>&1
-    then
-        die "ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH.
-
-Please set the JAVA_HOME variable in your environment to match the
-location of your Java installation."
-    fi
-fi
-
-# Increase the maximum file descriptors if we can.
-if ! "$cygwin" && ! "$darwin" && ! "$nonstop" ; then
-    case $MAX_FD in #(
-      max*)
-        # In POSIX sh, ulimit -H is undefined. That's why the result is checked to see if it worked.
-        # shellcheck disable=SC2039,SC3045
-        MAX_FD=$( ulimit -H -n ) ||
-            warn "Could not query maximum file descriptor limit"
-    esac
-    case $MAX_FD in  #(
-      '' | soft) :;; #(
-      *)
-        # In POSIX sh, ulimit -n is undefined. That's why the result is checked to see if it worked.
-        # shellcheck disable=SC2039,SC3045
-        ulimit -n "$MAX_FD" ||
-            warn "Could not set maximum file descriptor limit to $MAX_FD"
-    esac
-fi
-
-# Collect all arguments for the java command, stacking in reverse order:
-#   * args from the command line
-#   * the main class name
-#   * -classpath
-#   * -D...appname settings
-#   * --module-path (only if needed)
-#   * DEFAULT_JVM_OPTS, JAVA_OPTS, and GRADLE_OPTS environment variables.
-
-# For Cygwin or MSYS, switch paths to Windows format before running java
-if "$cygwin" || "$msys" ; then
-    APP_HOME=$( cygpath --path --mixed "$APP_HOME" )
-    CLASSPATH=$( cygpath --path --mixed "$CLASSPATH" )
-
-    JAVACMD=$( cygpath --unix "$JAVACMD" )
-
-    # Now convert the arguments - kludge to limit ourselves to /bin/sh
-    for arg do
-        if
-            case $arg in                                #(
-              -*)   false ;;                            # don't mess with options #(
-              /?*)  t=${arg#/} t=/${t%%/*}              # looks like a POSIX filepath
-                    [ -e "$t" ] ;;                      #(
-              *)    false ;;
-            esac
-        then
-            arg=$( cygpath --path --ignore --mixed "$arg" )
-        fi
-        # Roll the args list around exactly as many times as the number of
-        # args, so each arg winds up back in the position where it started, but
-        # possibly modified.
-        #
-        # NB: a `for` loop captures its iteration list before it begins, so
-        # changing the positional parameters here affects neither the number of
-        # iterations, nor the values presented in `arg`.
-        shift                   # remove old arg
-        set -- "$@" "$arg"      # push replacement arg
-    done
-fi
-
-
-# Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script.
-DEFAULT_JVM_OPTS='"-Xmx64m" "-Xms64m"'
-
-# Collect all arguments for the java command:
-#   * DEFAULT_JVM_OPTS, JAVA_OPTS, JAVA_OPTS, and optsEnvironmentVar are not allowed to contain shell fragments,
-#     and any embedded shellness will be escaped.
-#   * For example: A user cannot expect ${Hostname} to be expanded, as it is an environment variable and will be
-#     treated as '${Hostname}' itself on the command line.
-
-set -- \
-        "-Dorg.gradle.appname=$APP_BASE_NAME" \
-        -classpath "$CLASSPATH" \
-        org.gradle.wrapper.GradleWrapperMain \
-        "$@"
-
-# Stop when "xargs" is not available.
-if ! command -v xargs >/dev/null 2>&1
-then
-    die "xargs is not available"
-fi
-
-# Use "xargs" to parse quoted args.
-#
-# With -n1 it outputs one arg per line, with the quotes and backslashes removed.
-#
-# In Bash we could simply go:
-#
-#   readarray ARGS < <( xargs -n1 <<<"$var" ) &&
-#   set -- "${ARGS[@]}" "$@"
-#
-# but POSIX shell has neither arrays nor command substitution, so instead we
-# post-process each arg (as a line of input to sed) to backslash-escape any
-# character that might be a shell metacharacter, then use eval to reverse
-# that process (while maintaining the separation between arguments), and wrap
-# the whole thing up as a single "set" statement.
-#
-# This will of course break if any of these variables contains a newline or
-# an unmatched quote.
-#
-
-eval "set -- $(
-        printf '%s\n' "$DEFAULT_JVM_OPTS $JAVA_OPTS $GRADLE_OPTS" |
-        xargs -n1 |
-        sed ' s~[^-[:alnum:]+,./:=@_]~\\&~g; ' |
-        tr '\n' ' '
-    )" '"$@"'
-
-exec "$JAVACMD" "$@"

android/gradlew.bat

@@ -1,92 +0,0 @@
-@rem
-@rem Copyright 2015 the original author or authors.
-@rem
-@rem Licensed under the Apache License, Version 2.0 (the "License");
-@rem you may not use this file except in compliance with the License.
-@rem You may obtain a copy of the License at
-@rem
-@rem      https://www.apache.org/licenses/LICENSE-2.0
-@rem
-@rem Unless required by applicable law or agreed to in writing, software
-@rem distributed under the License is distributed on an "AS IS" BASIS,
-@rem WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-@rem See the License for the specific language governing permissions and
-@rem limitations under the License.
-@rem
-
-@if "%DEBUG%"=="" @echo off
-@rem ##########################################################################
-@rem
-@rem  Gradle startup script for Windows
-@rem
-@rem ##########################################################################
-
-@rem Set local scope for the variables with windows NT shell
-if "%OS%"=="Windows_NT" setlocal
-
-set DIRNAME=%~dp0
-if "%DIRNAME%"=="" set DIRNAME=.
-@rem This is normally unused
-set APP_BASE_NAME=%~n0
-set APP_HOME=%DIRNAME%
-
-@rem Resolve any "." and ".." in APP_HOME to make it shorter.
-for %%i in ("%APP_HOME%") do set APP_HOME=%%~fi
-
-@rem Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script.
-set DEFAULT_JVM_OPTS="-Xmx64m" "-Xms64m"
-
-@rem Find java.exe
-if defined JAVA_HOME goto findJavaFromJavaHome
-
-set JAVA_EXE=java.exe
-%JAVA_EXE% -version >NUL 2>&1
-if %ERRORLEVEL% equ 0 goto execute
-
-echo. 1>&2
-echo ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH. 1>&2
-echo. 1>&2
-echo Please set the JAVA_HOME variable in your environment to match the 1>&2
-echo location of your Java installation. 1>&2
-
-goto fail
-
-:findJavaFromJavaHome
-set JAVA_HOME=%JAVA_HOME:"=%
-set JAVA_EXE=%JAVA_HOME%/bin/java.exe
-
-if exist "%JAVA_EXE%" goto execute
-
-echo. 1>&2
-echo ERROR: JAVA_HOME is set to an invalid directory: %JAVA_HOME% 1>&2
-echo. 1>&2
-echo Please set the JAVA_HOME variable in your environment to match the 1>&2
-echo location of your Java installation. 1>&2
-
-goto fail
-
-:execute
-@rem Setup the command line
-
-set CLASSPATH=%APP_HOME%\gradle\wrapper\gradle-wrapper.jar
-
-
-@rem Execute Gradle
-"%JAVA_EXE%" %DEFAULT_JVM_OPTS% %JAVA_OPTS% %GRADLE_OPTS% "-Dorg.gradle.appname=%APP_BASE_NAME%" -classpath "%CLASSPATH%" org.gradle.wrapper.GradleWrapperMain %*
-
-:end
-@rem End local scope for the variables with windows NT shell
-if %ERRORLEVEL% equ 0 goto mainEnd
-
-:fail
-rem Set variable GRADLE_EXIT_CONSOLE if you need the _script_ return code instead of
-rem the _cmd.exe /c_ return code!
-set EXIT_CODE=%ERRORLEVEL%
-if %EXIT_CODE% equ 0 set EXIT_CODE=1
-if not ""=="%GRADLE_EXIT_CONSOLE%" exit %EXIT_CODE%
-exit /b %EXIT_CODE%
-
-:mainEnd
-if "%OS%"=="Windows_NT" endlocal
-
-:omega

android/settings.gradle.kts

@@ -1,28 +0,0 @@
-pluginManagement {
-    repositories {
-        val localChaquopyRepo = file(System.getenv("LOCAL_CHAQUOPY_REPO") ?: ".m2-chaquopy")
-        if (localChaquopyRepo.isDirectory) {
-            maven(url = localChaquopyRepo.toURI())
-        }
-        maven("https://chaquo.com/maven")
-        gradlePluginPortal()
-        google()
-        mavenCentral()
-    }
-}
-
-dependencyResolutionManagement {
-    repositoriesMode.set(RepositoriesMode.FAIL_ON_PROJECT_REPOS)
-    repositories {
-        val localChaquopyRepo = file(System.getenv("LOCAL_CHAQUOPY_REPO") ?: ".m2-chaquopy")
-        if (localChaquopyRepo.isDirectory) {
-            maven(url = localChaquopyRepo.toURI())
-        }
-        maven("https://chaquo.com/maven")
-        google()
-        mavenCentral()
-    }
-}
-
-rootProject.name = "tg-ws-proxy-android"
-include(":app")

docs/CfProxy.md

@@ -0,0 +1,29 @@
+# Cloudflare Proxy
+
+Для недоступных датацентров можно использовать альтернативный бесплатный метод подключения - проксирование через Cloudflare. **Для работы нужен только домен**. В приложении есть домен по умолчанию, но его можно (и лучше) заменить на свой.
+  
+Прокси возвращает доступ к тому, что до этого не грузило (реакциям, некоторым стикерам). Если у вас до этого не грузило видео/фото на аккаунте без премиума, то уберите всё кроме `4:149.154.167.220` из `DC->IP` блока в настройках. Если CF-прокси у вас работает - медиа снова начнёт грузиться.
+
+## Зачем мне настраивать свой домен?
+Cloudflare имеет лимиты на одновременное количество подключений WS. Домен по умолчанию может перестать работать в любой момент. 
+
+## Настройка своего домена
+1. Добавьте свой домен в Cloudflare (либо купив у них напрямую, либо поменяв NS сервера: https://developers.cloudflare.com/dns/zone-setups/full-setup/setup/). Домены стоят +- 150 рублей на год, подойдёт любой.
+
+2. В `SSL/TLS` -> `Overview` выставьте режим **Flexible**
+
+3. В `DNS` -> `Records` добавьте следующие `A` записи через `+ Add Record`:
+- Name=`kws1`   IPv4=`149.154.175.50`
+- Name=`kws2`   IPv4=`149.154.167.51`
+- Name=`kws3`   IPv4=`149.154.175.100`
+- Name=`kws4`   IPv4=`149.154.167.91`
+- Name=`kws5`   IPv4=`149.154.171.5`
+- Name=`kws203` IPv4=`91.105.192.100`
+
+4. **Добавьте домен в [zapret](https://github.com/Flowseal/zapret-discord-youtube/) или другой софт для обхода блокировок, так как подсеть Cloudflare забанена (по крайней мере, если вы из России)**
+
+5. В настройках TgWsProxy поменяйте домен на свой
+
+## Mentions
+Idea - https://github.com/Nekogram/WSProxy  
+Thanks to [@UjuiUjuMandan](https://github.com/UjuiUjuMandan) for the information

docs/README.md

@@ -1,3 +1,11 @@
+> [!TIP]
+>
+> ### 🎉 Поддержать меня
+>
+> USDT (TRC20): `TXPnKs2Ww1RD8JN6nChFUVmi5r2hqrWjuu`  
+> BTC: `bc1qr8vd6jelkyyry3m4mq6z5txdx4pl856fu6ss0w`  
+> ETH: `0x1417878fdc5047E670a77748B34819b9A49C72F1`  
+
 > [!CAUTION]
 >
 > ### Реакция антивирусов
@@ -12,21 +20,27 @@
 
 # TG WS Proxy
 
-**Локальный SOCKS5-прокси** для Telegram Desktop, который **ускоряет работу Telegram**, перенаправляя трафик через WebSocket-соединения. Данные передаются в том же зашифрованном виде, а для работы не нужны сторонние сервера.
+**Локальный MTProto-прокси** для Telegram Desktop, который **ускоряет работу Telegram**, перенаправляя трафик через WebSocket-соединения. Данные передаются в том же зашифрованном виде, а для работы не нужны сторонние сервера.
 
 <img width="529" height="487" alt="image" src="https://github.com/user-attachments/assets/6a4cf683-0df8-43af-86c1-0e8f08682b62" />
 
 ## Как это работает
 
 ```
-Telegram Desktop → SOCKS5 (127.0.0.1:1080) → TG WS Proxy → WSS → Telegram DC
+Telegram Desktop → MTProto Proxy (127.0.0.1:1443) → WebSocket → Telegram DC
 ```
 
-1. Приложение поднимает локальный SOCKS5-прокси на `127.0.0.1:1080`
+1. Приложение поднимает MTProto прокси на `127.0.0.1:1443`
 2. Перехватывает подключения к IP-адресам Telegram
 3. Извлекает DC ID из MTProto obfuscation init-пакета
 4. Устанавливает WebSocket (TLS) соединение к соответствующему DC через домены Telegram
-5. Если WS недоступен (302 redirect) — автоматически переключается на прямое TCP-соединение
+5. Если WS недоступен (302 redirect) — автоматически переключается на CfProxy / прямое TCP-соединение
+
+> [!IMPORTANT] 
+> ### Не грузит фото/видео?
+> ### Удалите в настройках прокси в DC->IP всё, кроме `4:149.154.167.220`
+> Подобная проблема встречается на аккаунтах без Premium  
+> Если вам не помогло, то настраивайте свой домен по гайду отсюда: https://github.com/Flowseal/tg-ws-proxy/blob/main/docs/CfProxy.md
 
 ## 🚀 Быстрый старт
 
@@ -38,7 +52,7 @@ Telegram Desktop → SOCKS5 (127.0.0.1:1080) → TG WS Proxy → WSS → Telegra
 
 **Меню трея:**
 
-- **Открыть в Telegram** — автоматически настроить прокси через `tg://socks` ссылку
+- **Открыть в Telegram** — автоматически настроить прокси через `tg://proxy` ссылку
 - **Перезапустить прокси** — перезапуск без выхода из приложения
 - **Настройки...** — GUI-редактор конфигурации (в т.ч. версия приложения, опциональная проверка обновлений с GitHub)
 - **Открыть логи** — открыть файл логов
@@ -69,8 +83,9 @@ makepkg -si
 # При помощи AUR-helper
 paru -S tg-ws-proxy-bin
 
-# Если вы установили -cli пакет, то запуск осуществляется через systemctl, где 8888 это номер порта прокси:
+# Если вы установили -cli пакет, то запуск осуществляется через systemctl, где 8888 это номер порта,
-sudo systemctl start tg-ws-proxy-cli@8888
+# разделитель ":" и secret, который можно сгенерировать командой: openssl rand -hex 16
+sudo systemctl start tg-ws-proxy-cli@8888:3075abe65830f0325116bb0416cadf9f
 ```
 
 Для остальных дистрибутивов можно использовать **`TgWsProxy_linux_amd64`** (бинарный файл для x86_64).
@@ -82,28 +97,11 @@ chmod +x TgWsProxy_linux_amd64
 
 При первом запуске откроется окно с инструкцией. Приложение работает в системном трее (требуется AppIndicator).
 
-### Android
-
-Перейдите на [страницу релизов](https://github.com/Flowseal/tg-ws-proxy/releases) и скачайте подписанный APK вида **`tg-ws-proxy-android-vX.Y.Z.apk`**.
-
-После установки:
-
-- откройте приложение
-- проверьте `Android background limits`
-- при необходимости отключите battery optimization и снимите background restrictions
-- нажмите **Start Service**
-- нажмите **Open in Telegram**
-
-Что важно для стабильной работы на Android:
-
-- разрешите уведомления
-- отключите battery optimization для приложения
-
 ## Установка из исходников
 
 ### Консольный proxy
 
-Для запуска только SOCKS5/WebSocket proxy без tray-интерфейса достаточно базовой установки:
+Для запуска только proxy без tray-интерфейса достаточно базовой установки:
 
 ```bash
 pip install -e .
@@ -137,65 +135,22 @@ tg-ws-proxy-tray-linux
 tg-ws-proxy [--port PORT] [--host HOST] [--dc-ip DC:IP ...] [-v]
 ```
 
-### Android debug APK
-
-Требуются JDK 17, Android SDK и Gradle. Локальная debug-сборка:
-
-```bash
-./android/build-local-debug.sh assembleStandardDebug
-```
-
-Результат:
-
-```text
-android/app/build/outputs/apk/standard/debug/app-standard-debug.apk
-```
-
-Legacy32 debug-сборка:
-
-```bash
-./android/build-local-debug.sh assembleLegacy32Debug
-```
-
-Результат:
-
-```text
-android/app/build/outputs/apk/legacy32/debug/app-legacy32-debug.apk
-```
-
-### Android signed release APK
-
-Для локальной release-сборки нужен keystore и переменные окружения:
-
-```bash
-export ANDROID_KEYSTORE_FILE=/path/to/tg-ws-proxy-release.keystore
-export ANDROID_KEYSTORE_PASSWORD=...
-export ANDROID_KEY_ALIAS=tg-ws-proxy
-export ANDROID_KEY_PASSWORD=...
-```
-
-Сборка:
-
-```bash
-cd android
-./build-local-debug.sh assembleStandardRelease
-./build-local-debug.sh assembleLegacy32Release
-```
-
-Результат:
-
-```text
-android/app/build/outputs/apk/standard/release/app-standard-release.apk
-android/app/build/outputs/apk/legacy32/release/app-legacy32-release.apk
-```
-
 **Аргументы:**
 
 | Аргумент | По умолчанию | Описание |
 |---|---|---|
-| `--port` | `1080` | Порт SOCKS5-прокси |
+| `--port` | `1443` | Порт прокси |
-| `--host` | `127.0.0.1` | Хост SOCKS5-прокси |
+| `--host` | `127.0.0.1` | Хост прокси |
+| `--secret` | `random` | 32 hex chars secret для авторизации клиентов |
 | `--dc-ip` | `2:149.154.167.220`, `4:149.154.167.220` | Целевой IP для DC (можно указать несколько раз) |
+| `--no-cfproxy` | `false` | Отключить попытку [проксирования через Cloudflare]((https://github.com/Flowseal/tg-ws-proxy/blob/main/docs/CfProxy.md)) |
+| `--cfproxy-domain` | | Указать свой домен для проксирования через Cloudfalre. [Подробнее тут](https://github.com/Flowseal/tg-ws-proxy/blob/main/docs/CfProxy.md) |
+| `--cfproxy-priority` | `true` | Пробовать проксировать через Cloudflare перед прямым TCP подключением |
+| `--buf-kb` | `256` | Размер буфера в КБ |
+| `--pool-size` | `4` | Количество заготовленных соединений на каждый DC |
+| `--log-file` | выкл. | Путь до файла, в который сохранять логи  |
+| `--log-max-mb` | `5` | Максимальный размер файла логов в МБ (после идёт перезапись) |
+| `--log-backups` | `0` | Количество сохранений логов после перезаписи |
 | `-v`, `--verbose` | выкл. | Подробное логирование (DEBUG) |
 
 **Примеры:**
@@ -211,20 +166,6 @@ tg-ws-proxy --port 9050 --dc-ip 1:149.154.175.205 --dc-ip 2:149.154.167.220
 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
 
 ### Автоматически
@@ -235,30 +176,10 @@ tg-ws-proxy-tray-linux = "linux:main"
 
 1. Telegram → **Настройки** → **Продвинутые настройки** → **Тип подключения** → **Прокси**
 2. Добавить прокси:
-   - **Тип:** SOCKS5
+   - **Тип:** MTProto
-   - **Сервер:** `127.0.0.1`
+   - **Сервер:** `127.0.0.1` (или переопределенный вами)
-   - **Порт:** `1080`
+   - **Порт:** `1443` (или переопределенный вами)
-   - **Логин/Пароль:** оставить пустыми
+   - **Secret:** из настроек или логов
-
-## Настройка Telegram Android
-
-### Автоматически
-
-В приложении нажмите **Open in Telegram** после запуска foreground service.
-
-### Вручную
-
-1. Telegram → **Настройки** → **Данные и память** → **Настройки прокси**
-2. Добавить прокси:
-   - **Тип:** SOCKS5
-   - **Сервер:** `127.0.0.1`
-   - **Порт:** `1080`
-   - **Логин/Пароль:** оставить пустыми
-
-Важно:
-
-- сначала должен быть запущен foreground service
-- если Telegram был уже открыт, иногда проще закрыть и открыть его заново после запуска прокси
 
 ## Конфигурация
 
@@ -271,7 +192,8 @@ Tray-приложение хранит данные в:
 ```json
 {
   "host": "127.0.0.1",
-  "port": 1080,
+  "port": 1443,
+  "secret": "...",
   "dc_ip": [
     "2:149.154.167.220",
     "4:149.154.167.220"
@@ -299,17 +221,6 @@ Tray-приложение хранит данные в:
 - Apple Silicon macOS 11.0+
 - Linux x86_64 (требуется AppIndicator для системного трея)
 
-Android-артефакты:
-
-- `tg-ws-proxy-android-vX.Y.Z.apk`
-- `tg-ws-proxy-android-vX.Y.Z-legacy32.apk`
-
-Для signed Android release в GitHub Actions нужны secrets:
-
-- `ANDROID_KEYSTORE_BASE64`
-- `ANDROID_KEYSTORE_PASSWORD`
-- `ANDROID_KEY_ALIAS`
-- `ANDROID_KEY_PASSWORD`
 ## Лицензия
 
 [MIT License](LICENSE)

linux.py

@@ -1,241 +1,44 @@
 from __future__ import annotations
 
-import json
-import logging
-import logging.handlers
 import os
 import subprocess
 import sys
 import threading
-import webbrowser
 import time
-from pathlib import Path
 from typing import Optional
 
 import customtkinter as ctk
-import psutil
 import pyperclip
 import pystray
-from PIL import Image, ImageDraw, ImageFont
+from PIL import Image, ImageTk
 
-import proxy.tg_ws_proxy as tg_ws_proxy
+from proxy import get_link_host
-from proxy.app_runtime import ProxyAppRuntime
+
-from proxy import __version__
+from utils.tray_common import (
-from utils.default_config import default_tray_config
+    APP_NAME, DEFAULT_CONFIG, FIRST_RUN_MARKER, LOG_FILE,
+    acquire_lock, bootstrap, check_ipv6_warning, ctk_run_dialog,
+    ensure_ctk_thread, ensure_dirs, load_config, load_icon, log,
+    maybe_notify_update, quit_ctk, release_lock, restart_proxy,
+    save_config, start_proxy, stop_proxy, tg_proxy_url,
+)
 from ui.ctk_tray_ui import (
-    install_tray_config_buttons,
+    install_tray_config_buttons, install_tray_config_form,
-    install_tray_config_form,
+    populate_first_run_window, tray_settings_scroll_and_footer,
-    populate_first_run_window,
-    tray_settings_scroll_and_footer,
     validate_config_form,
 )
 from ui.ctk_theme import (
-    CONFIG_DIALOG_FRAME_PAD,
+    CONFIG_DIALOG_FRAME_PAD, CONFIG_DIALOG_SIZE, FIRST_RUN_SIZE,
-    CONFIG_DIALOG_SIZE,
+    create_ctk_toplevel, ctk_theme_for_platform, main_content_frame,
-    FIRST_RUN_SIZE,
-    create_ctk_root,
-    ctk_theme_for_platform,
-    main_content_frame,
 )
 
-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 = default_tray_config()
-
-
 _tray_icon: Optional[object] = None
 _config: dict = {}
-_exiting: bool = False
+_exiting = False
-_lock_file_path: Optional[Path] = None
 
-log = logging.getLogger("tg-ws-tray")
+# dialogs (tkinter messagebox)
-_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:
+def _msgbox(kind: str, text: str, title: str, **kw):
-    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():
-    _runtime.ensure_dirs()
-
-
-def load_config() -> dict:
-    return _runtime.load_config()
-
-
-def save_config(cfg: dict):
-    _runtime.save_config(cfg)
-
-
-def setup_logging(verbose: bool = False, log_max_mb: float = 5):
-    _runtime.setup_logging(verbose, log_max_mb=log_max_mb)
-
-
-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 start_proxy():
-    _runtime.start_proxy(_config)
-
-
-def stop_proxy():
-    _runtime.stop_proxy()
-
-
-def restart_proxy():
-    _runtime.restart_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 _ask_yes_no_dialog(text: str, title: str = "TG WS Proxy") -> bool:
     import tkinter as _tk
     from tkinter import messagebox as _mb
 
@@ -245,273 +48,189 @@ def _ask_yes_no_dialog(text: str, title: str = "TG WS Proxy") -> bool:
         root.attributes("-topmost", True)
     except Exception:
         pass
-    r = _mb.askyesno(title, text, parent=root)
+    result = getattr(_mb, kind)(title, text, parent=root, **kw)
     root.destroy()
-    return bool(r)
+    return result
 
 
-def _maybe_notify_update_async():
+def _show_error(text: str, title: str = "TG WS Proxy — Ошибка") -> None:
-    def _work():
+    _msgbox("showerror", text, title)
-        time.sleep(1.5)
-        if _exiting:
-            return
-        if not _config.get("check_updates", True):
-            return
-        try:
-            from utils.update_check import RELEASES_PAGE_URL, get_status, run_check
-            run_check(__version__)
-            st = get_status()
-            if not st.get("has_update"):
-                return
-            url = (st.get("html_url") or "").strip() or RELEASES_PAGE_URL
-            ver = st.get("latest") or "?"
-            text = (
-                f"Доступна новая версия: {ver}\n\n"
-                f"Открыть страницу релиза в браузере?"
-            )
-            if _ask_yes_no_dialog(text, "TG WS Proxy — обновление"):
-                webbrowser.open(url)
-        except Exception as exc:
-            log.debug("Update check failed: %s", exc)
-
-    threading.Thread(target=_work, daemon=True, name="update-check").start()
 
 
-def _on_open_in_telegram(icon=None, item=None):
+def _show_info(text: str, title: str = "TG WS Proxy") -> None:
-    host = _config.get("host", DEFAULT_CONFIG["host"])
+    _msgbox("showinfo", text, title)
-    port = _config.get("port", DEFAULT_CONFIG["port"])
+
-    url = f"tg://socks?server={host}&port={port}"
+
+def _ask_yes_no(text: str, title: str = "TG WS Proxy") -> bool:
+    return bool(_msgbox("askyesno", text, title))
+
+
+def _apply_window_icon(root) -> None:
+    icon_img = load_icon()
+    if icon_img:
+        root._ctk_icon_photo = ImageTk.PhotoImage(icon_img.resize((64, 64)))
+        root.iconphoto(False, root._ctk_icon_photo)
+
+
+# tray callbacks
+
+
+def _on_open_in_telegram(icon=None, item=None) -> None:
+    url = tg_proxy_url(_config)
     log.info("Copying %s", url)
-
     try:
         pyperclip.copy(url)
         _show_info(
-            f"Ссылка скопирована в буфер обмена, отправьте её в Telegram и нажмите по ней ЛКМ:\n{url}",
+            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):
+def _on_copy_link(icon=None, item=None) -> None:
-    threading.Thread(target=restart_proxy, daemon=True).start()
+    url = tg_proxy_url(_config)
+    log.info("Copying link: %s", url)
+    try:
+        pyperclip.copy(url)
+    except Exception as exc:
+        log.error("Clipboard copy failed: %s", exc)
+        _show_error(f"Не удалось скопировать ссылку:\n{exc}")
 
 
-def _on_edit_config(icon=None, item=None):
+def _on_restart(icon=None, item=None) -> None:
+    threading.Thread(
+        target=lambda: restart_proxy(_config, _show_error), daemon=True
+    ).start()
+
+
+def _on_edit_config(icon=None, item=None) -> None:
     threading.Thread(target=_edit_config_dialog, daemon=True).start()
 
 
-def _edit_config_dialog():
+def _on_open_logs(icon=None, item=None) -> None:
-    if ctk is None:
-        _show_error("customtkinter не установлен.")
-        return
-
-    cfg = dict(_config)
-
-    theme = ctk_theme_for_platform()
-    w, h = CONFIG_DIALOG_SIZE
-
-    root = create_ctk_root(
-        ctk,
-        title="TG WS Proxy — Настройки",
-        width=w,
-        height=h,
-        theme=theme,
-        after_create=_apply_linux_ctk_window_icon,
-    )
-
-    fpx, fpy = CONFIG_DIALOG_FRAME_PAD
-    frame = main_content_frame(ctk, root, theme, padx=fpx, pady=fpy)
-
-    scroll, footer = tray_settings_scroll_and_footer(ctk, frame, theme)
-
-    widgets = install_tray_config_form(
-        ctk, scroll, theme, cfg, DEFAULT_CONFIG,
-        show_autostart=False,
-    )
-
-    def on_save():
-        merged = validate_config_form(
-            widgets, DEFAULT_CONFIG, include_autostart=False)
-        if isinstance(merged, str):
-            _show_error(merged)
-            return
-
-        new_cfg = merged
-        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()
-
-    install_tray_config_buttons(
-        ctk, footer, theme, on_save=on_save, on_cancel=on_cancel)
-
-    try:
-        root.mainloop()
-    finally:
-        import tkinter as tk
-        try:
-            if root.winfo_exists():
-                root.destroy()
-        except tk.TclError:
-            pass
-
-
-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 = {k: v for k, v in os.environ.items() if k not in ("VIRTUAL_ENV", "PYTHONPATH", "PYTHONHOME")}
-        env.pop("VIRTUAL_ENV", None)
-        env.pop("PYTHONPATH", None)
-        env.pop("PYTHONHOME", None)
-
         subprocess.Popen(
-            ["xdg-open", str(LOG_FILE)],
+            ["xdg-open", str(LOG_FILE)], env=env,
-            env=env,
+            stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL,
-            stdout=subprocess.DEVNULL,
+            stdin=subprocess.DEVNULL, start_new_session=True,
-            stderr=subprocess.DEVNULL,
-            stdin=subprocess.DEVNULL,
-            start_new_session=True,
         )
     else:
-        _show_info("Файл логов ещё не создан.", "TG WS Proxy")
+        _show_info("Файл логов ещё не создан.")
 
 
-def _on_exit(icon=None, item=None):
+def _on_exit(icon=None, item=None) -> None:
     global _exiting
     if _exiting:
         os._exit(0)
         return
     _exiting = True
     log.info("User requested exit")
-
+    quit_ctk()
-    def _force_exit():
+    threading.Thread(target=lambda: (time.sleep(3), os._exit(0)), daemon=True, name="force-exit").start()
-        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():
+# settings dialog
-    _ensure_dirs()
+
+
+def _edit_config_dialog() -> None:
+    if not ensure_ctk_thread(ctk, _config.get("appearance", "auto")):
+        _show_error("customtkinter не установлен.")
+        return
+
+    cfg = dict(_config)
+
+    def _build(done: threading.Event) -> None:
+        theme = ctk_theme_for_platform()
+        w, h = CONFIG_DIALOG_SIZE
+        root = create_ctk_toplevel(
+            ctk, title="TG WS Proxy — Настройки", width=w, height=h, theme=theme,
+            after_create=_apply_window_icon,
+        )
+        fpx, fpy = CONFIG_DIALOG_FRAME_PAD
+        frame = main_content_frame(ctk, root, theme, padx=fpx, pady=fpy)
+        scroll, footer = tray_settings_scroll_and_footer(ctk, frame, theme)
+        widgets = install_tray_config_form(ctk, scroll, theme, cfg, DEFAULT_CONFIG, show_autostart=False)
+
+        def _finish() -> None:
+            root.destroy()
+            done.set()
+
+        def on_save() -> None:
+            from tkinter import messagebox
+            merged = validate_config_form(widgets, DEFAULT_CONFIG, include_autostart=False)
+            if isinstance(merged, str):
+                messagebox.showerror("TG WS Proxy — Ошибка", merged, parent=root)
+                return
+            save_config(merged)
+            _config.update(merged)
+            log.info("Config saved: %s", merged)
+            _tray_icon.menu = _build_menu()
+
+            do_restart = messagebox.askyesno(
+                "Перезапустить?",
+                "Настройки сохранены.\n\nПерезапустить прокси сейчас?",
+                parent=root,
+            )
+            _finish()
+            if do_restart:
+                threading.Thread(target=lambda: restart_proxy(_config, _show_error), daemon=True).start()
+
+        root.protocol("WM_DELETE_WINDOW", _finish)
+        install_tray_config_buttons(ctk, footer, theme, on_save=on_save, on_cancel=_finish)
+
+    ctk_run_dialog(_build)
+
+
+# first run
+
+
+def _show_first_run() -> None:
+    ensure_dirs()
     if FIRST_RUN_MARKER.exists():
         return
+    if not ensure_ctk_thread(ctk, _config.get("appearance", "auto")):
+        FIRST_RUN_MARKER.touch()
+        return
 
     host = _config.get("host", DEFAULT_CONFIG["host"])
     port = _config.get("port", DEFAULT_CONFIG["port"])
+    secret = _config.get("secret", DEFAULT_CONFIG["secret"])
 
-    if ctk is None:
+    def _build(done: threading.Event) -> None:
-        FIRST_RUN_MARKER.touch()
+        theme = ctk_theme_for_platform()
-        return
+        w, h = FIRST_RUN_SIZE
+        root = create_ctk_toplevel(
+            ctk, title="TG WS Proxy", width=w, height=h, theme=theme,
+            after_create=_apply_window_icon,
+        )
 
-    theme = ctk_theme_for_platform()
+        def on_done(open_tg: bool) -> None:
-    w, h = FIRST_RUN_SIZE
+            FIRST_RUN_MARKER.touch()
+            root.destroy()
+            done.set()
+            if open_tg:
+                _on_open_in_telegram()
 
-    root = create_ctk_root(
+        populate_first_run_window(ctk, root, theme, host=host, port=port, secret=secret, on_done=on_done)
-        ctk,
-        title="TG WS Proxy",
-        width=w,
-        height=h,
-        theme=theme,
-        after_create=_apply_linux_ctk_window_icon,
-    )
 
-    def on_done(open_tg: bool):
+    ctk_run_dialog(_build)
-        FIRST_RUN_MARKER.touch()
-        root.destroy()
-        if open_tg:
-            _on_open_in_telegram()
-
-    populate_first_run_window(
-        ctk, root, theme, host=host, port=port, on_done=on_done)
-
-    try:
-        root.mainloop()
-    finally:
-        import tkinter as tk
-        try:
-            if root.winfo_exists():
-                root.destroy()
-        except tk.TclError:
-            pass
 
 
-def _has_ipv6_enabled() -> bool:
+# tray menu
-    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"])
+    link_host = get_link_host(host)
     return pystray.Menu(
-        pystray.MenuItem(
+        pystray.MenuItem(f"Открыть в Telegram ({link_host}:{port})", _on_open_in_telegram, default=True),
-            f"Открыть в Telegram ({host}:{port})", _on_open_in_telegram, default=True
+        pystray.MenuItem("Скопировать ссылку", _on_copy_link),
-        ),
         pystray.Menu.SEPARATOR,
         pystray.MenuItem("Перезапустить прокси", _on_restart),
         pystray.MenuItem("Настройки...", _on_edit_config),
@@ -521,21 +240,18 @@ def _build_menu():
     )
 
 
-def run_tray():
+# entry point
+
+
+def run_tray() -> None:
     global _tray_icon, _config
 
-    _config = _runtime.prepare()
+    _config = load_config()
-    _runtime.reset_log_file()
+    bootstrap(_config)
-
-    setup_logging(_config.get("verbose", False),
-                  log_max_mb=_config.get("log_max_mb", DEFAULT_CONFIG["log_max_mb"]))
-    log.info("TG WS Proxy версия %s, tray app starting", __version__)
-    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()
+        start_proxy(_config, _show_error)
         try:
             while True:
                 time.sleep(1)
@@ -543,16 +259,12 @@ def run_tray():
             stop_proxy()
         return
 
-    start_proxy()
+    start_proxy(_config, _show_error)
-
+    maybe_notify_update(_config, lambda: _exiting, _ask_yes_no)
-    _maybe_notify_update_async()
-
     _show_first_run()
-    _check_ipv6_warning()
+    check_ipv6_warning(_show_info)
-
-    icon_image = _load_icon()
-    _tray_icon = pystray.Icon(APP_NAME, icon_image, "TG WS Proxy", menu=_build_menu())
 
+    _tray_icon = pystray.Icon(APP_NAME, load_icon(), "TG WS Proxy", menu=_build_menu())
     log.info("Tray icon running")
     _tray_icon.run()
 
@@ -560,15 +272,14 @@ def run_tray():
     log.info("Tray app exited")
 
 
-def main():
+def main() -> None:
-    if not _acquire_lock():
+    if not acquire_lock("linux.py"):
         _show_info("Приложение уже запущено.", os.path.basename(sys.argv[0]))
         return
-
     try:
         run_tray()
     finally:
-        _release_lock()
+        release_lock()
 
 
 if __name__ == "__main__":

macos.py

@@ -1,10 +1,6 @@
 from __future__ import annotations
 
-import json
-import logging
-import logging.handlers
 import os
-import psutil
 import subprocess
 import sys
 import threading
@@ -28,242 +24,190 @@ try:
 except ImportError:
     pyperclip = None
 
-import proxy.tg_ws_proxy as tg_ws_proxy
+from proxy import __version__, get_link_host, parse_dc_ip_list, proxy_config
-from proxy.app_runtime import ProxyAppRuntime
+from proxy.tg_ws_proxy import _run
-from proxy import __version__
+
-from utils.default_config import default_tray_config
+from utils.tray_common import (
+    APP_DIR, APP_NAME, DEFAULT_CONFIG, FIRST_RUN_MARKER, IPV6_WARN_MARKER,
+    LOG_FILE, acquire_lock, apply_proxy_config, ensure_dirs, load_config,
+    log, release_lock, save_config, setup_logging, stop_proxy, tg_proxy_url,
+)
 
-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 = default_tray_config()
+_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")
+# osascript dialogs
-_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
 
 
-# Single-instance lock
+def _esc(text: str) -> str:
+    return text.replace("\\", "\\\\").replace('"', '\\"')
 
-def _same_process(lock_meta: dict, proc: psutil.Process) -> bool:
+
-    try:
+def _osascript(script: str) -> str:
-        lock_ct = float(lock_meta.get("create_time", 0.0))
+    r = subprocess.run(["osascript", "-e", script], capture_output=True, text=True)
-        proc_ct = float(proc.create_time())
+    return r.stdout.strip()
-        if lock_ct > 0 and abs(lock_ct - proc_ct) > 1.0:
+
-            return False
+
-    except Exception:
+def _show_error(text: str, title: str = "TG WS Proxy") -> None:
+    _osascript(
+        f'display dialog "{_esc(text)}" with title "{_esc(title)}" '
+        f'buttons {{"OK"}} default button "OK" with icon stop'
+    )
+
+
+def _show_info(text: str, title: str = "TG WS Proxy") -> None:
+    _osascript(
+        f'display dialog "{_esc(text)}" with title "{_esc(title)}" '
+        f'buttons {{"OK"}} default button "OK" with icon note'
+    )
+
+
+def _ask_yes_no(text: str, title: str = "TG WS Proxy") -> bool:
+    return _ask_yes_no_close(text, title) is True
+
+
+def _ask_yes_no_close(text: str, title: str = "TG WS Proxy") -> Optional[bool]:
+    r = subprocess.run(
+        [
+            "osascript", "-e",
+            f'button returned of (display dialog "{_esc(text)}" '
+            f'with title "{_esc(title)}" '
+            f'buttons {{"Закрыть", "Нет", "Да"}} '
+            f'default button "Да" cancel button "Закрыть" with icon note)',
+        ],
+        capture_output=True, text=True,
+    )
+    if r.returncode != 0:
+        return None
+    btn = r.stdout.strip()
+    if btn == "Да":
+        return True
+    if btn == "Нет":
         return False
-
+    return None
-    frozen = bool(getattr(sys, "frozen", False))
-    if frozen:
-        return APP_NAME.lower() in proc.name().lower()
-    return False
 
 
-def _release_lock():
+def _osascript_input(prompt: str, default: str, title: str = "TG WS Proxy") -> Optional[str]:
-    global _lock_file_path
+    r = subprocess.run(
-    if not _lock_file_path:
+        [
-        return
+            "osascript", "-e",
-    try:
+            f'text returned of (display dialog "{_esc(prompt)}" '
-        _lock_file_path.unlink(missing_ok=True)
+            f'default answer "{_esc(default)}" '
-    except Exception:
+            f'with title "{_esc(title)}" '
-        pass
+            f'buttons {{"Закрыть", "OK"}} '
-    _lock_file_path = None
+            f'default button "OK" cancel button "Закрыть")',
+        ],
+        capture_output=True, text=True,
+    )
+    if r.returncode != 0:
+        return None
+    return r.stdout.rstrip("\r\n")
 
 
-def _acquire_lock() -> bool:
+# menubar icon
-    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():
-    _runtime.ensure_dirs()
-
-
-def load_config() -> dict:
-    return _runtime.load_config()
-
-
-def save_config(cfg: dict):
-    _runtime.save_config(cfg)
-
-
-def setup_logging(verbose: bool = False, log_max_mb: float = 5):
-    _runtime.setup_logging(verbose, log_max_mb=log_max_mb)
-
-
-# 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],
+    draw.ellipse([margin, margin, size - margin, size - margin], fill=(0, 0, 0, 255))
-                 fill=(0, 0, 0, 255))
-
     try:
-        font = ImageFont.truetype(
+        font = ImageFont.truetype("/System/Library/Fonts/Helvetica.ttc", size=int(size * 0.55))
-            "/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]
+    draw.text(
-    ty = (size - th) // 2 - bbox[1]
+        ((size - tw) // 2 - bbox[0], (size - th) // 2 - bbox[1]),
-    draw.text((tx, ty), "T", fill=(255, 255, 255, 255), font=font)
+        "T", fill=(255, 255, 255, 255), font=font,
+    )
     return img
 
-# Generate menubar icon PNG if it does not exist.
+
-def _ensure_menubar_icon():
+def _ensure_menubar_icon() -> None:
     if MENUBAR_ICON_PATH.exists():
         return
-    _ensure_dirs()
+    ensure_dirs()
     img = _make_menubar_icon(44)
     if img:
         img.save(str(MENUBAR_ICON_PATH), "PNG")
 
 
-# Native macOS dialogs
+# proxy lifecycle (macOS-local)
 
-def _escape_osascript_text(text: str) -> str:
+import asyncio as _asyncio
-    return text.replace('\\', '\\\\').replace('"', '\\"')
 
 
-def _osascript(script: str) -> str:
+def _run_proxy_thread() -> None:
-    r = subprocess.run(
+    global _async_stop
-        ['osascript', '-e', script],
+    loop = _asyncio.new_event_loop()
-        capture_output=True, text=True)
+    _asyncio.set_event_loop(loop)
-    return r.stdout.strip()
+    stop_ev = _asyncio.Event()
+    _async_stop = (loop, stop_ev)
+    try:
+        loop.run_until_complete(_run(stop_event=stop_ev))
+    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 _show_error(text: str, title: str = "TG WS Proxy"):
+def _start_proxy() -> None:
-    text_esc = _escape_osascript_text(text)
+    global _proxy_thread
-    title_esc = _escape_osascript_text(title)
+    if _proxy_thread and _proxy_thread.is_alive():
-    _osascript(
+        log.info("Proxy already running")
-        f'display dialog "{text_esc}" with title "{title_esc}" '
+        return
-        f'buttons {{"OK"}} default button "OK" with icon stop')
+    if not apply_proxy_config(_config):
+        _show_error("Ошибка конфигурации DC → IP.")
+        return
+    pc = proxy_config
+    log.info("Starting proxy on %s:%d ...", pc.host, pc.port)
+    _proxy_thread = threading.Thread(target=_run_proxy_thread, daemon=True, name="proxy")
+    _proxy_thread.start()
 
 
-def _show_info(text: str, title: str = "TG WS Proxy"):
+def _stop_proxy() -> None:
-    text_esc = _escape_osascript_text(text)
+    global _proxy_thread, _async_stop
-    title_esc = _escape_osascript_text(title)
+    if _async_stop:
-    _osascript(
+        loop, stop_ev = _async_stop
-        f'display dialog "{text_esc}" with title "{title_esc}" '
+        loop.call_soon_threadsafe(stop_ev.set)
-        f'buttons {{"OK"}} default button "OK" with icon note')
+        if _proxy_thread:
+            _proxy_thread.join(timeout=2)
+    _proxy_thread = None
+    log.info("Proxy stopped")
 
 
-def _ask_yes_no(text: str, title: str = "TG WS Proxy") -> bool:
+def _restart_proxy() -> None:
-    result = _ask_yes_no_close(text, title)
+    log.info("Restarting proxy...")
-    return result is True
+    _stop_proxy()
+    time.sleep(0.3)
+    _start_proxy()
 
 
-def _ask_yes_no_close(text: str,
+# menu callbacks
-                      title: str = "TG WS Proxy") -> Optional[bool]:
-    text_esc = _escape_osascript_text(text)
-    title_esc = _escape_osascript_text(title)
-    r = subprocess.run(
-        ['osascript', '-e',
-         f'button returned of (display dialog "{text_esc}" '
-         f'with title "{title_esc}" '
-         f'buttons {{"Закрыть", "Нет", "Да"}} '
-         f'default button "Да" cancel button "Закрыть" with icon note)'],
-        capture_output=True, text=True)
-    if r.returncode != 0:
-        return None
-
-    result = r.stdout.strip()
-    if result == "Да":
-        return True
-    if result == "Нет":
-        return False
-    return None
 
 
-# Proxy lifecycle
+def _on_open_in_telegram(_=None) -> None:
-
+    url = tg_proxy_url(_config)
-def start_proxy():
-    _runtime.start_proxy(_config)
-
-
-def stop_proxy():
-    _runtime.stop_proxy()
-
-
-def restart_proxy():
-    _runtime.restart_proxy()
-
-
-# Menu callbacks
-
-def _on_open_in_telegram(_=None):
-    host = _config.get("host", DEFAULT_CONFIG["host"])
-    port = _config.get("port", DEFAULT_CONFIG["port"])
-    url = f"tg://socks?server={host}&port={port}"
     log.info("Opening %s", url)
     try:
-        result = subprocess.call(['open', url])
+        result = subprocess.call(["open", url])
         if result != 0:
             raise RuntimeError("open command failed")
     except Exception:
@@ -277,67 +221,58 @@ def _on_open_in_telegram(_=None):
                 if pyperclip:
                     pyperclip.copy(url)
                 else:
-                    subprocess.run(['pbcopy'], input=url.encode(),
+                    subprocess.run(["pbcopy"], input=url.encode(), check=True)
-                                   check=True)
                 _show_info(
                     "Не удалось открыть Telegram автоматически.\n\n"
-                    f"Ссылка скопирована в буфер обмена:\n{url}")
+                    f"Ссылка скопирована в буфер обмена:\n{url}"
+                )
             except Exception as exc:
                 log.error("Clipboard copy failed: %s", exc)
                 _show_error(f"Не удалось скопировать ссылку:\n{exc}")
 
 
-def _on_restart(_=None):
+def _on_copy_link(_=None) -> None:
-    def _do_restart():
+    url = tg_proxy_url(_config)
+    log.info("Copying link: %s", url)
+    try:
+        if pyperclip:
+            pyperclip.copy(url)
+        else:
+            subprocess.run(["pbcopy"], input=url.encode(), check=True)
+    except Exception as exc:
+        log.error("Clipboard copy failed: %s", exc)
+        _show_error(f"Не удалось скопировать ссылку:\n{exc}")
+
+
+def _on_restart(_=None) -> None:
+    def _do():
         global _config
         _config = load_config()
         if _app:
             _app.update_menu_title()
-        restart_proxy()
+        _restart_proxy()
 
-    threading.Thread(target=_do_restart, daemon=True).start()
+    threading.Thread(target=_do, daemon=True).start()
 
 
-def _on_open_logs(_=None):
+def _on_open_logs(_=None) -> None:
     log.info("Opening log file: %s", LOG_FILE)
     if LOG_FILE.exists():
-        subprocess.call(['open', str(LOG_FILE)])
+        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 = _escape_osascript_text(prompt)
-    default_esc = _escape_osascript_text(default)
-    title_esc = _escape_osascript_text(title)
-    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"}} '
-         f'default button "OK" cancel button "Закрыть")'],
-        capture_output=True, text=True)
-    if r.returncode != 0:
-        return None
-    return r.stdout.rstrip("\r\n")
 
-
+def _on_edit_config(_=None) -> None:
-def _on_edit_config(_=None):
     threading.Thread(target=_edit_config_dialog, daemon=True).start()
 
 
 def _check_updates_menu_title() -> str:
     on = bool(_config.get("check_updates", True))
-    return (
+    return "✓ Проверять обновления при запуске" if on else "Проверять обновления при запуске (выкл)"
-        "✓ Проверять обновления при запуске"
-        if on
-        else "Проверять обновления при запуске (выкл)"
-    )
 
 
-def _toggle_check_updates(_=None):
+def _toggle_check_updates(_=None) -> None:
     global _config
     _config["check_updates"] = not bool(_config.get("check_updates", True))
     save_config(_config)
@@ -345,12 +280,15 @@ def _toggle_check_updates(_=None):
         _app._check_updates_item.title = _check_updates_menu_title()
 
 
-def _on_open_release_page(_=None):
+def _on_open_release_page(_=None) -> None:
     from utils.update_check import RELEASES_PAGE_URL
     webbrowser.open(RELEASES_PAGE_URL)
 
 
-def _maybe_notify_update_async():
+# update check
+
+
+def _maybe_notify_update_async() -> None:
     def _work():
         time.sleep(1.5)
         if _exiting:
@@ -366,8 +304,7 @@ def _maybe_notify_update_async():
             url = (st.get("html_url") or "").strip() or RELEASES_PAGE_URL
             ver = st.get("latest") or "?"
             if _ask_yes_no(
-                f"Доступна новая версия: {ver}\n\n"
+                f"Доступна новая версия: {ver}\n\nОткрыть страницу релиза в браузере?",
-                f"Открыть страницу релиза в браузере?",
                 "TG WS Proxy — обновление",
             ):
                 webbrowser.open(url)
@@ -377,18 +314,16 @@ def _maybe_notify_update_async():
     threading.Thread(target=_work, daemon=True, name="update-check").start()
 
 
-# Settings via native macOS dialogs
+# settings dialog
-def _edit_config_dialog():
+
+
+def _edit_config_dialog() -> None:
     cfg = load_config()
 
-    # Host
+    host = _osascript_input("IP-адрес прокси:", cfg.get("host", DEFAULT_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)
@@ -396,10 +331,7 @@ def _edit_config_dialog():
         _show_error("Некорректный IP-адрес.")
         return
 
-    # Port
+    port_str = _osascript_input("Порт прокси:", str(cfg.get("port", DEFAULT_CONFIG["port"])))
-    port_str = _osascript_input(
-        "Порт прокси:",
-        str(cfg.get("port", DEFAULT_CONFIG["port"])))
     if port_str is None:
         return
     try:
@@ -410,42 +342,49 @@ def _edit_config_dialog():
         _show_error("Порт должен быть числом 1-65535")
         return
 
-    # DC-IP mappings
+    secret_str = _osascript_input(
+        "MTProto Secret (32 hex символа):", cfg.get("secret", DEFAULT_CONFIG["secret"])
+    )
+    if secret_str is None:
+        return
+    secret_str = secret_str.strip().lower()
+    if len(secret_str) != 32 or not all(c in "0123456789abcdef" for c in secret_str):
+        _show_error("Secret должен быть строкой из 32 шестнадцатеричных символов.")
+        return
+
     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)
+        dc_default,
+    )
     if dc_str is None:
         return
-    dc_lines = [s.strip() for s in dc_str.replace(',', '\n').splitlines()
+    dc_lines = [s.strip() for s in dc_str.replace(",", "\n").splitlines() if s.strip()]
-                if s.strip()]
     try:
-        tg_ws_proxy.parse_dc_ip_list(dc_lines)
+        parse_dc_ip_list(dc_lines)
     except ValueError as e:
         _show_error(str(e))
         return
 
-    # Verbose
     verbose = _ask_yes_no_close("Включить подробное логирование (verbose)?")
     if verbose is None:
         return
 
-    # Advanced settings
     adv_str = _osascript_input(
         "Расширенные настройки (буфер KB, WS пул, лог MB):\n"
         "Формат: buf_kb,pool_size,log_max_mb",
         f"{cfg.get('buf_kb', DEFAULT_CONFIG['buf_kb'])},"
         f"{cfg.get('pool_size', DEFAULT_CONFIG['pool_size'])},"
-        f"{cfg.get('log_max_mb', DEFAULT_CONFIG['log_max_mb'])}")
+        f"{cfg.get('log_max_mb', DEFAULT_CONFIG['log_max_mb'])}",
+    )
     if adv_str is None:
         return
 
     adv = {}
     if adv_str:
-        parts = [s.strip() for s in adv_str.split(',')]
+        parts = [s.strip() for s in adv_str.split(",")]
-        keys = [("buf_kb", int), ("pool_size", int),
+        keys = [("buf_kb", int), ("pool_size", int), ("log_max_mb", float)]
-                ("log_max_mb", float)]
         for i, (k, typ) in enumerate(keys):
             if i < len(parts):
                 try:
@@ -453,14 +392,39 @@ def _edit_config_dialog():
                 except ValueError:
                     pass
 
+    cfproxy = _ask_yes_no_close("Включить Cloudflare Proxy (CfProxy)?")
+    if cfproxy is None:
+        return
+
+    cfproxy_priority = True
+    if cfproxy:
+        cfproxy_priority_result = _ask_yes_no_close("Приоритет CfProxy (пробовать раньше прямого TCP)?")
+        if cfproxy_priority_result is None:
+            return
+        cfproxy_priority = cfproxy_priority_result
+
+    cfproxy_domain = _osascript_input(
+        "Свой CF-домен (оставьте пустым для автоматического выбора):\n"
+        "DNS записи kws1-kws5,kws203 должны указывать на IP датацентров Telegram через Cloudflare.",
+        cfg.get("cfproxy_user_domain", DEFAULT_CONFIG.get("cfproxy_user_domain", "")),
+    )
+    if cfproxy_domain is None:
+        return
+    cfproxy_domain = cfproxy_domain.strip()
+
     new_cfg = {
         "host": host,
         "port": port,
+        "secret": secret_str,
         "dc_ip": dc_lines,
         "verbose": verbose,
         "buf_kb": adv.get("buf_kb", cfg.get("buf_kb", DEFAULT_CONFIG["buf_kb"])),
         "pool_size": adv.get("pool_size", cfg.get("pool_size", DEFAULT_CONFIG["pool_size"])),
         "log_max_mb": adv.get("log_max_mb", cfg.get("log_max_mb", DEFAULT_CONFIG["log_max_mb"])),
+        "check_updates": cfg.get("check_updates", True),
+        "cfproxy": cfproxy,
+        "cfproxy_priority": cfproxy_priority,
+        "cfproxy_user_domain": cfproxy_domain,
     }
     save_config(new_cfg)
     log.info("Config saved: %s", new_cfg)
@@ -470,21 +434,23 @@ def _edit_config_dialog():
     if _app:
         _app.update_menu_title()
 
-    if _ask_yes_no_close(
+    if _ask_yes_no_close("Настройки сохранены.\n\nПерезапустить прокси сейчас?"):
-            "Настройки сохранены.\n\nПерезапустить прокси сейчас?"):
+        _restart_proxy()
-        restart_proxy()
 
 
-# First-run & IPv6 dialogs
+# first run & ipv6
 
-def _show_first_run():
+
-    _ensure_dirs()
+def _show_first_run() -> None:
+    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}"
+    secret = _config.get("secret", DEFAULT_CONFIG["secret"])
+    tg_url = tg_proxy_url(_config)
+    link_host = get_link_host(host)
 
     text = (
         f"Прокси запущен и работает в строке меню.\n\n"
@@ -494,54 +460,54 @@ def _show_first_run():
         f"  Или ссылка: {tg_url}\n\n"
         f"Вручную:\n"
         f"  Настройки → Продвинутые → Тип подключения → Прокси\n"
-        f"  SOCKS5 → {host} : {port} (без логина/пароля)\n\n"
+        f"  MTProto → {link_host} : {port} \n"
+        f"  Secret: dd{secret} \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:
+def _check_ipv6_warning() -> None:
-    import socket as _sock
+    ensure_dirs()
-    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():
+
+    import socket as _sock
+    has = False
+    try:
+        for addr in _sock.getaddrinfo(_sock.gethostname(), None, _sock.AF_INET6):
+            ip = addr[4][0]
+            if ip and not ip.startswith("::1") and not ip.startswith("fe80::1"):
+                has = True
+                break
+    except Exception:
+        pass
+    if not has:
+        try:
+            s = _sock.socket(_sock.AF_INET6, _sock.SOCK_STREAM)
+            s.bind(("::1", 0))
+            s.close()
+            has = True
+        except Exception:
+            pass
+    if not has:
         return
 
     IPV6_WARN_MARKER.touch()
-
     _show_info(
         "На вашем компьютере включена поддержка подключения по IPv6.\n\n"
         "Telegram может пытаться подключаться через IPv6, "
         "что не поддерживается и может привести к ошибкам.\n\n"
         "Если прокси не работает, попробуйте отключить "
         "попытку соединения по IPv6 в настройках прокси Telegram.\n\n"
-        "Это предупреждение будет показано только один раз.")
+        "Это предупреждение будет показано только один раз."
+    )
 
 
-# rumps menubar app
+# rumps app
 
 _TgWsProxyAppBase = rumps.App if rumps else object
 
@@ -549,33 +515,26 @@ _TgWsProxyAppBase = rumps.App if rumps else object
 class TgWsProxyApp(_TgWsProxyAppBase):
     def __init__(self):
         _ensure_menubar_icon()
-        icon_path = (str(MENUBAR_ICON_PATH)
+        icon_path = str(MENUBAR_ICON_PATH) if MENUBAR_ICON_PATH.exists() else None
-                     if MENUBAR_ICON_PATH.exists() else None)
 
         host = _config.get("host", DEFAULT_CONFIG["host"])
         port = _config.get("port", DEFAULT_CONFIG["port"])
+        link_host = get_link_host(host)
 
         self._open_tg_item = rumps.MenuItem(
-            f"Открыть в Telegram ({host}:{port})",
+            f"Открыть в Telegram ({link_host}:{port})", callback=_on_open_in_telegram
-            callback=_on_open_in_telegram)
+        )
-        self._restart_item = rumps.MenuItem(
+        self._copy_link_item = rumps.MenuItem("Скопировать ссылку", callback=_on_copy_link)
-            "Перезапустить прокси",
+        self._restart_item = rumps.MenuItem("Перезапустить прокси", callback=_on_restart)
-            callback=_on_restart)
+        self._settings_item = rumps.MenuItem("Настройки...", callback=_on_edit_config)
-        self._settings_item = rumps.MenuItem(
+        self._logs_item = rumps.MenuItem("Открыть логи", callback=_on_open_logs)
-            "Настройки...",
-            callback=_on_edit_config)
-        self._logs_item = rumps.MenuItem(
-            "Открыть логи",
-            callback=_on_open_logs)
         self._release_page_item = rumps.MenuItem(
-            "Страница релиза на GitHub…",
+            "Страница релиза на GitHub…", callback=_on_open_release_page
-            callback=_on_open_release_page)
+        )
         self._check_updates_item = rumps.MenuItem(
-            _check_updates_menu_title(),
+            _check_updates_menu_title(), callback=_toggle_check_updates
-            callback=_toggle_check_updates)
+        )
-        self._version_item = rumps.MenuItem(
+        self._version_item = rumps.MenuItem(f"Версия {__version__}", callback=lambda _: None)
-            f"Версия {__version__}",
-            callback=lambda _: None)
 
         super().__init__(
             "TG WS Proxy",
@@ -584,6 +543,7 @@ class TgWsProxyApp(_TgWsProxyAppBase):
             quit_button="Выход",
             menu=[
                 self._open_tg_item,
+                self._copy_link_item,
                 None,
                 self._restart_item,
                 self._settings_item,
@@ -593,41 +553,51 @@ class TgWsProxyApp(_TgWsProxyAppBase):
                 self._check_updates_item,
                 None,
                 self._version_item,
-            ])
+            ],
+        )
 
-    def update_menu_title(self):
+    def update_menu_title(self) -> None:
         host = _config.get("host", DEFAULT_CONFIG["host"])
         port = _config.get("port", DEFAULT_CONFIG["port"])
-        self._open_tg_item.title = (
+        link_host = get_link_host(host)
-            f"Открыть в Telegram ({host}:{port})")
+        self._open_tg_item.title = f"Открыть в Telegram ({link_host}:{port})"
 
 
-def run_menubar():
+# entry point
+
+
+def run_menubar() -> None:
     global _app, _config
 
-    _config = _runtime.prepare()
+    _config = load_config()
-    _runtime.reset_log_file()
+    save_config(_config)
 
-    setup_logging(_config.get("verbose", False),
+    if LOG_FILE.exists():
-                  log_max_mb=_config.get("log_max_mb", DEFAULT_CONFIG["log_max_mb"]))
+        try:
+            LOG_FILE.unlink()
+        except Exception:
+            pass
+
+    setup_logging(
+        _config.get("verbose", False),
+        log_max_mb=_config.get("log_max_mb", DEFAULT_CONFIG["log_max_mb"]),
+    )
     log.info("TG WS Proxy версия %s, menubar app starting", __version__)
     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()
+        _start_proxy()
         try:
             while True:
                 time.sleep(1)
         except KeyboardInterrupt:
-            stop_proxy()
+            _stop_proxy()
         return
 
-    start_proxy()
+    _start_proxy()
-
     _maybe_notify_update_async()
-
     _show_first_run()
     _check_ipv6_warning()
 
@@ -635,19 +605,18 @@ def run_menubar():
     log.info("Menubar app running")
     _app.run()
 
-    stop_proxy()
+    _stop_proxy()
     log.info("Menubar app exited")
 
 
-def main():
+def main() -> None:
-    if not _acquire_lock():
+    if not acquire_lock("macos.py"):
         _show_info("Приложение уже запущено.")
         return
-
     try:
         run_menubar()
     finally:
-        _release_lock()
+        release_lock()
 
 
 if __name__ == "__main__":

packaging/linux.spec

@@ -46,11 +46,25 @@ a = Analysis(
     hookspath=[],
     hooksconfig={},
     runtime_hooks=[],
-    excludes=[],
+    excludes=[
+        'PIL._avif',
+        'PIL._webp',
+        'PIL._imagingtk',
+    ],
     noarchive=False,
     cipher=block_cipher,
 )
 
+_PIL_EXCLUDE_PYDS = {
+    '_avif', '_webp', '_imagingtk',
+    'FpxImagePlugin', 'MicImagePlugin',
+}
+a.binaries = [
+    (name, path, typ)
+    for name, path, typ in a.binaries
+    if not any(ex in name for ex in _PIL_EXCLUDE_PYDS)
+]
+
 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')]

packaging/macos.spec

@@ -25,11 +25,25 @@ a = Analysis(
     hookspath=[],
     hooksconfig={},
     runtime_hooks=[],
-    excludes=[],
+    excludes=[
+        'PIL._avif',
+        'PIL._webp',
+        'PIL._imagingtk',
+    ],
     noarchive=False,
     cipher=block_cipher,
 )
 
+_PIL_EXCLUDE_PYDS = {
+    '_avif', '_webp', '_imagingtk',
+    'FpxImagePlugin', 'MicImagePlugin',
+}
+a.binaries = [
+    (name, path, typ)
+    for name, path, typ in a.binaries
+    if not any(ex in name for ex in _PIL_EXCLUDE_PYDS)
+]
+
 icon_path = os.path.join(os.path.dirname(SPEC), os.pardir, 'icon.icns')
 if not os.path.exists(icon_path):
     icon_path = None

packaging/version_info.txt

@@ -0,0 +1,36 @@
+# UTF-8
+#
+# For more details about fixed file info 'ffi' see:
+# http://msdn.microsoft.com/en-us/library/ms646997.aspx
+VSVersionInfo(
+  ffi=FixedFileInfo(
+    filevers=(1, 0, 0, 0),
+    prodvers=(1, 0, 0, 0),
+    mask=0x3f,
+    flags=0x0,
+    OS=0x40004,
+    fileType=0x1,
+    subtype=0x0,
+    date=(0, 0)
+  ),
+  kids=[
+    StringFileInfo(
+      [
+        StringTable(
+          u'040904B0',
+          [
+            StringStruct(u'CompanyName', u'Flowseal'),
+            StringStruct(u'FileDescription', u'Telegram Desktop WebSocket Bridge Proxy'),
+            StringStruct(u'FileVersion', u'1.0.0.0'),
+            StringStruct(u'InternalName', u'TgWsProxy'),
+            StringStruct(u'LegalCopyright', u'Copyright (c) Flowseal. MIT License.'),
+            StringStruct(u'OriginalFilename', u'TgWsProxy.exe'),
+            StringStruct(u'ProductName', u'TG WS Proxy'),
+            StringStruct(u'ProductVersion', u'1.0.0.0'),
+          ]
+        )
+      ]
+    ),
+    VarFileInfo([VarStruct(u'Translation', [1033, 1200])])
+  ]
+)

packaging/windows.spec

@@ -26,14 +26,29 @@ a = Analysis(
     hookspath=[],
     hooksconfig={},
     runtime_hooks=[],
-    excludes=[],
+    excludes=[
+        'PIL._avif',
+        'PIL._webp',
+        'PIL._imagingtk',
+    ],
     win_no_prefer_redirects=False,
     win_private_assemblies=False,
     cipher=block_cipher,
     noarchive=False,
 )
 
+_PIL_EXCLUDE_PYDS = {
+    '_avif', '_webp', '_imagingtk',
+    'FpxImagePlugin', 'MicImagePlugin',
+}
+a.binaries = [
+    (name, path, typ)
+    for name, path, typ in a.binaries
+    if not any(ex in name for ex in _PIL_EXCLUDE_PYDS)
+]
+
 icon_path = os.path.join(os.path.dirname(SPEC), os.pardir, 'icon.ico')
+version_path = os.path.join(os.path.dirname(SPEC), 'version_info.txt')
 if os.path.exists(icon_path):
     a.datas += [('icon.ico', icon_path, 'DATA')]
 
@@ -50,7 +65,7 @@ exe = EXE(
     debug=False,
     bootloader_ignore_signals=False,
     strip=False,
-    upx=True,
+    upx=False,
     upx_exclude=[],
     runtime_tmpdir=None,
     console=False,
@@ -60,4 +75,5 @@ exe = EXE(
     codesign_identity=None,
     entitlements_file=None,
     icon=icon_path if os.path.exists(icon_path) else None,
+    version=version_path if os.path.exists(version_path) else None,
 )

proxy/__init__.py

@@ -1 +1,6 @@
-__version__ = "1.3.0"
+from .config import parse_dc_ip_list, proxy_config
+from .utils import get_link_host
+
+__version__ = "1.6.0"
+
+__all__ = ["__version__", "get_link_host", "proxy_config", "parse_dc_ip_list"]

proxy/app_runtime.py

@@ -1,203 +0,0 @@
-from __future__ import annotations
-
-import asyncio as _asyncio
-import json
-import logging
-import logging.handlers
-import sys
-import threading
-import time
-from pathlib import Path
-from typing import Callable, Dict, Optional
-
-import proxy.tg_ws_proxy as tg_ws_proxy
-
-
-DEFAULT_CONFIG = {
-    "port": 1080,
-    "host": "127.0.0.1",
-    "dc_ip": ["2:149.154.167.220", "4:149.154.167.220"],
-    "log_max_mb": 5,
-    "buf_kb": 256,
-    "pool_size": 4,
-    "verbose": False,
-}
-
-
-class ProxyAppRuntime:
-    def __init__(self, app_dir: Path,
-                 default_config: Optional[dict] = None,
-                 logger_name: str = "tg-ws-runtime",
-                 on_error: Optional[Callable[[str], None]] = None,
-                 parse_dc_ip_list: Optional[
-                     Callable[[list[str]], Dict[int, str]]
-                 ] = None,
-                 run_proxy: Optional[Callable[..., object]] = None,
-                 thread_factory: Optional[Callable[..., object]] = None):
-        self.app_dir = Path(app_dir)
-        self.config_file = self.app_dir / "config.json"
-        self.log_file = self.app_dir / "proxy.log"
-        self.default_config = dict(default_config or DEFAULT_CONFIG)
-        self.log = logging.getLogger(logger_name)
-        self.on_error = on_error
-        self.parse_dc_ip_list = parse_dc_ip_list or \
-            tg_ws_proxy.parse_dc_ip_list
-        self.run_proxy = run_proxy or tg_ws_proxy._run
-        self.thread_factory = thread_factory or threading.Thread
-        self.config: dict = {}
-        self._proxy_thread = None
-        self._async_stop = None
-
-    def ensure_dirs(self):
-        self.app_dir.mkdir(parents=True, exist_ok=True)
-
-    def load_config(self) -> dict:
-        self.ensure_dirs()
-        if self.config_file.exists():
-            try:
-                with open(self.config_file, "r", encoding="utf-8") as f:
-                    data = json.load(f)
-                for key, value in self.default_config.items():
-                    data.setdefault(key, value)
-                self.config = data
-                return data
-            except Exception as exc:
-                self.log.warning("Failed to load config: %s", exc)
-
-        self.config = dict(self.default_config)
-        return dict(self.config)
-
-    def save_config(self, cfg: dict):
-        self.ensure_dirs()
-        self.config = dict(cfg)
-        with open(self.config_file, "w", encoding="utf-8") as f:
-            json.dump(cfg, f, indent=2, ensure_ascii=False)
-
-    def reset_log_file(self):
-        if self.log_file.exists():
-            try:
-                self.log_file.unlink()
-            except Exception:
-                pass
-
-    def setup_logging(self, verbose: bool = False, log_max_mb: float = 5):
-        self.ensure_dirs()
-        root = logging.getLogger()
-        root.setLevel(logging.DEBUG if verbose else logging.INFO)
-
-        for handler in list(root.handlers):
-            if getattr(handler, "_tg_ws_proxy_runtime_handler", False):
-                root.removeHandler(handler)
-                try:
-                    handler.close()
-                except Exception:
-                    pass
-
-        fh = logging.handlers.RotatingFileHandler(
-            str(self.log_file),
-            maxBytes=max(32 * 1024, log_max_mb * 1024 * 1024),
-            backupCount=0,
-            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"))
-        fh._tg_ws_proxy_runtime_handler = True
-        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"))
-            ch._tg_ws_proxy_runtime_handler = True
-            root.addHandler(ch)
-
-    def prepare(self) -> dict:
-        cfg = self.load_config()
-        self.save_config(cfg)
-        return cfg
-
-    def _emit_error(self, text: str):
-        if self.on_error:
-            self.on_error(text)
-
-    def _run_proxy_thread(self, port: int, dc_opt: Dict[int, str],
-                          host: str = "127.0.0.1"):
-        loop = _asyncio.new_event_loop()
-        _asyncio.set_event_loop(loop)
-        stop_ev = _asyncio.Event()
-        self._async_stop = (loop, stop_ev)
-
-        try:
-            loop.run_until_complete(
-                self.run_proxy(port, dc_opt, stop_event=stop_ev, host=host))
-        except Exception as exc:
-            self.log.error("Proxy thread crashed: %s", exc)
-            if ("10048" in str(exc) or
-                    "Address already in use" in str(exc)):
-                self._emit_error(
-                    "Не удалось запустить прокси:\n"
-                    "Порт уже используется другим приложением.\n\n"
-                    "Закройте приложение, использующее этот порт, "
-                    "или измените порт в настройках прокси и перезапустите.")
-        finally:
-            loop.close()
-            self._async_stop = None
-
-    def start_proxy(self, cfg: Optional[dict] = None) -> bool:
-        if self._proxy_thread and self._proxy_thread.is_alive():
-            self.log.info("Proxy already running")
-            return True
-
-        active_cfg = dict(cfg or self.config or self.default_config)
-        self.config = dict(active_cfg)
-        port = active_cfg.get("port", self.default_config["port"])
-        host = active_cfg.get("host", self.default_config["host"])
-        dc_ip_list = active_cfg.get("dc_ip", self.default_config["dc_ip"])
-        buf_kb = active_cfg.get("buf_kb", self.default_config["buf_kb"])
-        pool_size = active_cfg.get(
-            "pool_size", self.default_config["pool_size"])
-
-        try:
-            dc_opt = self.parse_dc_ip_list(dc_ip_list)
-        except ValueError as exc:
-            self.log.error("Bad config dc_ip: %s", exc)
-            self._emit_error("Ошибка конфигурации:\n%s" % exc)
-            return False
-
-        self.log.info("Starting proxy on %s:%d ...", host, port)
-        tg_ws_proxy._RECV_BUF = max(4, buf_kb) * 1024
-        tg_ws_proxy._SEND_BUF = tg_ws_proxy._RECV_BUF
-        tg_ws_proxy._WS_POOL_SIZE = max(0, pool_size)
-        self._proxy_thread = self.thread_factory(
-            target=self._run_proxy_thread,
-            args=(
-                port,
-                dc_opt,
-                host,
-            ),
-            daemon=True,
-            name="proxy")
-        self._proxy_thread.start()
-        return True
-
-    def stop_proxy(self):
-        if self._async_stop:
-            loop, stop_ev = self._async_stop
-            loop.call_soon_threadsafe(stop_ev.set)
-            if self._proxy_thread:
-                self._proxy_thread.join(timeout=2)
-        self._proxy_thread = None
-        self.log.info("Proxy stopped")
-
-    def restart_proxy(self, delay_seconds: float = 0.3) -> bool:
-        self.log.info("Restarting proxy...")
-        self.stop_proxy()
-        time.sleep(delay_seconds)
-        return self.start_proxy()
-
-    def is_proxy_running(self) -> bool:
-        return bool(self._proxy_thread and self._proxy_thread.is_alive())

proxy/bridge.py

@@ -0,0 +1,361 @@
+import asyncio
+import logging
+import struct
+
+from cryptography.hazmat.primitives.ciphers import Cipher, algorithms, modes
+from typing import Dict, List, Optional
+
+from .utils import *
+from .stats import stats
+from .config import proxy_config
+from .raw_websocket import RawWebSocket
+
+
+log = logging.getLogger('tg-mtproto-proxy')
+_st_I_le = struct.Struct('<I')
+
+ZERO_64 = b'\x00' * 64
+DC_DEFAULT_IPS: Dict[int, str] = {
+    1: '149.154.175.50',
+    2: '149.154.167.51',
+    3: '149.154.175.100',
+    4: '149.154.167.91',
+    5: '149.154.171.5',
+    203: '91.105.192.100'
+}
+
+
+class CryptoCtx:
+    __slots__ = ('clt_dec', 'clt_enc', 'tg_enc', 'tg_dec')
+
+    def __init__(self, clt_dec, clt_enc, tg_enc, tg_dec):
+        self.clt_dec = clt_dec  # decrypt from client
+        self.clt_enc = clt_enc  # encrypt to client
+        self.tg_enc = tg_enc    # encrypt to telegram
+        self.tg_dec = tg_dec    # decrypt from telegram
+
+
+class MsgSplitter:
+    """
+    Splits TCP stream data into individual MTProto transport packets
+    so each can be sent as a separate WS frame.
+    """
+    __slots__ = ('_dec', '_proto', '_cipher_buf', '_plain_buf', '_disabled')
+
+    def __init__(self, relay_init: bytes, proto_int: int):
+        cipher = Cipher(algorithms.AES(relay_init[8:40]),
+                        modes.CTR(relay_init[40:56]))
+        self._dec = cipher.encryptor()
+        self._dec.update(ZERO_64)
+        self._proto = proto_int
+        self._cipher_buf = bytearray()
+        self._plain_buf = bytearray()
+        self._disabled = False
+
+    def split(self, chunk: bytes) -> List[bytes]:
+        if not chunk:
+            return []
+        if self._disabled:
+            return [chunk]
+
+        self._cipher_buf.extend(chunk)
+        self._plain_buf.extend(self._dec.update(chunk))
+
+        parts = []
+        while self._cipher_buf:
+            packet_len = self._next_packet_len()
+            if packet_len is None:
+                break
+            if packet_len <= 0:
+                parts.append(bytes(self._cipher_buf))
+                self._cipher_buf.clear()
+                self._plain_buf.clear()
+                self._disabled = True
+                break
+            parts.append(bytes(self._cipher_buf[:packet_len]))
+            del self._cipher_buf[:packet_len]
+            del self._plain_buf[:packet_len]
+        return parts
+
+    def flush(self) -> List[bytes]:
+        if not self._cipher_buf:
+            return []
+        tail = bytes(self._cipher_buf)
+        self._cipher_buf.clear()
+        self._plain_buf.clear()
+        return [tail]
+
+    def _next_packet_len(self) -> Optional[int]:
+        if not self._plain_buf:
+            return None
+        if self._proto == PROTO_ABRIDGED_INT:
+            return self._next_abridged_len()
+        if self._proto in (PROTO_INTERMEDIATE_INT,
+                           PROTO_PADDED_INTERMEDIATE_INT):
+            return self._next_intermediate_len()
+        return 0
+
+    def _next_abridged_len(self) -> Optional[int]:
+        first = self._plain_buf[0]
+        if first in (0x7F, 0xFF):
+            if len(self._plain_buf) < 4:
+                return None
+            payload_len = int.from_bytes(self._plain_buf[1:4], 'little') * 4
+            header_len = 4
+        else:
+            payload_len = (first & 0x7F) * 4
+            header_len = 1
+        if payload_len <= 0:
+            return 0
+        packet_len = header_len + payload_len
+        if len(self._plain_buf) < packet_len:
+            return None
+        return packet_len
+
+    def _next_intermediate_len(self) -> Optional[int]:
+        if len(self._plain_buf) < 4:
+            return None
+        payload_len = _st_I_le.unpack_from(self._plain_buf, 0)[0] & 0x7FFFFFFF
+        if payload_len <= 0:
+            return 0
+        packet_len = 4 + payload_len
+        if len(self._plain_buf) < packet_len:
+            return None
+        return packet_len
+
+
+
+async def do_fallback(reader, writer, relay_init, label,
+                       dc, is_media, media_tag,
+                       ctx: CryptoCtx, splitter=None):
+    fallback_dst = DC_DEFAULT_IPS.get(dc)
+    use_cf = proxy_config.fallback_cfproxy
+    cf_first = proxy_config.fallback_cfproxy_priority
+
+    methods: List[str] = ['tcp']
+
+    if use_cf:
+        methods.insert(0 if cf_first else 1, 'cf')
+
+    for method in methods:
+        if method == 'cf':
+            ok = await _cfproxy_fallback(
+                reader, writer, relay_init, label,
+                dc=dc, is_media=is_media,
+                ctx=ctx, splitter=splitter)
+            if ok:
+                return True
+        elif method == 'tcp' and fallback_dst:
+            log.info("[%s] DC%d%s -> TCP fallback to %s:443",
+                     label, dc, media_tag, fallback_dst)
+            ok = await _tcp_fallback(
+                reader, writer, fallback_dst, 443,
+                relay_init, label, dc=dc, is_media=is_media, ctx=ctx)
+            if ok:
+                return True
+    return False
+
+
+async def _cfproxy_fallback(reader, writer, relay_init, label,
+                            dc=None, is_media=False,
+                            ctx: CryptoCtx = None, splitter=None):
+    media_tag = ' media' if is_media else ''
+
+    active = proxy_config.active_cfproxy_domain
+    others = [d for d in proxy_config.cfproxy_domains if d != active]
+
+    ws = None
+    chosen_domain = None
+
+    log.info("[%s] DC%d%s -> trying CF proxy",
+            label, dc, media_tag)
+
+    for base_domain in ([active] + others):
+        domain = f'kws{dc}.{base_domain}'
+        try:
+            ws = await RawWebSocket.connect(domain, domain, timeout=10.0)
+            chosen_domain = base_domain
+            break
+        except Exception as exc:
+            log.warning("[%s] DC%d%s CF proxy failed: %s",
+                        label, dc, media_tag, exc)
+
+    if ws is None:
+        return False
+
+    if chosen_domain and chosen_domain != proxy_config.active_cfproxy_domain:
+        log.info("[%s] Switching active CF domain", label)
+        proxy_config.active_cfproxy_domain = chosen_domain
+
+    stats.connections_cfproxy += 1
+    await ws.send(relay_init)
+    await bridge_ws_reencrypt(reader, writer, ws, label,
+                               dc=dc, is_media=is_media,
+                               ctx=ctx, splitter=splitter)
+    return True
+
+
+async def _tcp_fallback(reader, writer, dst, port, relay_init, label,
+                        dc=None, is_media=False, ctx: CryptoCtx = None):
+    try:
+        rr, rw = await asyncio.wait_for(
+            asyncio.open_connection(dst, port), timeout=10)
+    except Exception as exc:
+        log.warning("[%s] TCP fallback to %s:%d failed: %s",
+                    label, dst, port, exc)
+        return False
+
+    stats.connections_tcp_fallback += 1
+    rw.write(relay_init)
+    await rw.drain()
+    await _bridge_tcp_reencrypt(reader, writer, rr, rw, label,
+                                dc=dc, is_media=is_media, ctx=ctx)
+    return True
+
+
+async def bridge_ws_reencrypt(reader, writer, ws: RawWebSocket, label,
+                               dc=None, is_media=False,
+                               ctx: CryptoCtx = None,
+                               splitter: MsgSplitter = None):
+    """
+    Bidirectional TCP(client) <-> WS(telegram) with re-encryption.
+    client ciphertext → decrypt(clt_key) → encrypt(tg_key) → WS
+    WS data → decrypt(tg_key) → encrypt(clt_key) → client TCP
+    """
+    dc_tag = f"DC{dc}{'m' if is_media else ''}" if dc else "DC?"
+
+    up_bytes = 0
+    down_bytes = 0
+    up_packets = 0
+    down_packets = 0
+    start_time = asyncio.get_running_loop().time()
+
+    async def tcp_to_ws():
+        nonlocal up_bytes, up_packets
+        try:
+            while True:
+                chunk = await reader.read(65536)
+                if not chunk:
+                    if splitter:
+                        tail = splitter.flush()
+                        if tail:
+                            await ws.send(tail[0])
+                    break
+                n = len(chunk)
+                stats.bytes_up += n
+                up_bytes += n
+                up_packets += 1
+                plain = ctx.clt_dec.update(chunk)
+                chunk = ctx.tg_enc.update(plain)
+                if splitter:
+                    parts = splitter.split(chunk)
+                    if not parts:
+                        continue
+                    if len(parts) > 1:
+                        await ws.send_batch(parts)
+                    else:
+                        await ws.send(parts[0])
+                else:
+                    await ws.send(chunk)
+        except (asyncio.CancelledError, ConnectionError, OSError):
+            return
+        except Exception as e:
+            log.debug("[%s] tcp->ws ended: %s", label, e)
+
+    async def ws_to_tcp():
+        nonlocal down_bytes, down_packets
+        try:
+            while True:
+                data = await ws.recv()
+                if data is None:
+                    break
+                n = len(data)
+                stats.bytes_down += n
+                down_bytes += n
+                down_packets += 1
+                plain = ctx.tg_dec.update(data)
+                data = ctx.clt_enc.update(plain)
+                writer.write(data)
+                await writer.drain()
+        except (asyncio.CancelledError, ConnectionError, OSError):
+            return
+        except Exception as e:
+            log.debug("[%s] ws->tcp ended: %s", label, e)
+
+    tasks = [asyncio.create_task(tcp_to_ws()),
+             asyncio.create_task(ws_to_tcp())]
+    try:
+        await asyncio.wait(tasks, return_when=asyncio.FIRST_COMPLETED)
+    finally:
+        for t in tasks:
+            t.cancel()
+        for t in tasks:
+            try:
+                await t
+            except BaseException:
+                pass
+        elapsed = asyncio.get_running_loop().time() - start_time
+        log.info("[%s] %s WS session closed: "
+                 "^%s (%d pkts) v%s (%d pkts) in %.1fs",
+                 label, dc_tag,
+                 human_bytes(up_bytes), up_packets,
+                 human_bytes(down_bytes), down_packets,
+                 elapsed)
+        try:
+            await ws.close()
+        except BaseException:
+            pass
+        try:
+            writer.close()
+            await writer.wait_closed()
+        except BaseException:
+            pass
+
+
+async def _bridge_tcp_reencrypt(reader, writer, remote_reader, remote_writer,
+                                label, dc=None, is_media=False,
+                                ctx: CryptoCtx = None):
+    """Bidirectional TCP <-> TCP with re-encryption."""
+
+    async def forward(src, dst_w, is_up):
+        try:
+            while True:
+                data = await src.read(65536)
+                if not data:
+                    break
+                n = len(data)
+                if is_up:
+                    stats.bytes_up += n
+                    plain = ctx.clt_dec.update(data)
+                    data = ctx.tg_enc.update(plain)
+                else:
+                    stats.bytes_down += n
+                    plain = ctx.tg_dec.update(data)
+                    data = ctx.clt_enc.update(plain)
+                dst_w.write(data)
+                await dst_w.drain()
+        except asyncio.CancelledError:
+            pass
+        except Exception as e:
+            log.debug("[%s] forward ended: %s", label, e)
+
+    tasks = [
+        asyncio.create_task(forward(reader, remote_writer, True)),
+        asyncio.create_task(forward(remote_reader, writer, False)),
+    ]
+    try:
+        await asyncio.wait(tasks, return_when=asyncio.FIRST_COMPLETED)
+    finally:
+        for t in tasks:
+            t.cancel()
+        for t in tasks:
+            try:
+                await t
+            except BaseException:
+                pass
+        for w in (writer, remote_writer):
+            try:
+                w.close()
+                await w.wait_closed()
+            except BaseException:
+                pass

proxy/config.py

@@ -0,0 +1,109 @@
+import logging
+import os
+import string
+import random
+import socket as _socket
+import threading
+
+from dataclasses import dataclass, field
+from typing import Dict, List
+from urllib.request import Request, urlopen
+
+log = logging.getLogger('tg-mtproto-proxy')
+
+CFPROXY_DOMAINS_URL = (
+    "https://raw.githubusercontent.com/Flowseal/tg-ws-proxy/main"
+    "/.github/cfproxy-domains.txt"
+)
+
+_CFPROXY_ENC: List[str] = ['virkgj.com']
+_S = ''.join(chr(c) for c in (46, 99, 111, 46, 117, 107))
+
+
+def _dd(s: str) -> str:
+    """Only for decoding CF proxy domains"""
+    if not s[-4:] == '.com':
+        return s
+    p, n = s[:-4], sum(c.isalpha() for c in s[:-4])
+    return ''.join(
+        chr((ord(c) - (97 if c > '`' else 65) - n) % 26 + (97 if c > '`' else 65))
+        if c.isalpha() else c for c in p
+    ) + _S
+
+
+CFPROXY_DEFAULT_DOMAINS: List[str] = [_dd(d) for d in _CFPROXY_ENC]
+
+
+@dataclass
+class ProxyConfig:
+    port: int = 1443
+    host: str = '127.0.0.1'
+    secret: str = field(default_factory=lambda: os.urandom(16).hex())
+    dc_redirects: Dict[int, str] = field(default_factory=lambda: {2: '149.154.167.220', 4: '149.154.167.220'})
+    buffer_size: int = 256 * 1024
+    pool_size: int = 4
+    fallback_cfproxy: bool = True
+    fallback_cfproxy_priority: bool = True
+    cfproxy_user_domain: str = ''
+    cfproxy_domains: List[str] = field(default_factory=lambda: list(CFPROXY_DEFAULT_DOMAINS))
+    active_cfproxy_domain: str = field(default_factory=lambda: random.choice(CFPROXY_DEFAULT_DOMAINS))
+
+
+proxy_config = ProxyConfig()
+
+
+def _fetch_cfproxy_domain_list() -> List[str]:
+    try:
+        req = Request(CFPROXY_DOMAINS_URL + "?" + "".join(random.choices(string.ascii_letters, k=7)),
+                       headers={'User-Agent': 'tg-ws-proxy'})
+        with urlopen(req, timeout=10) as resp:
+            text = resp.read().decode('utf-8', errors='replace')
+        encoded = [
+            line.strip() for line in text.splitlines()
+            if line.strip() and not line.startswith('#')
+        ]
+        return [_dd(d) for d in encoded]
+    except Exception as exc:
+        log.warning("Failed to fetch CF proxy domain list: %s", exc)
+        return []
+
+
+def refresh_cfproxy_domains() -> None:
+    if proxy_config.cfproxy_user_domain:
+        return
+    
+    fetched = _fetch_cfproxy_domain_list()
+
+    if fetched:
+        seen = set()
+        pool = [d for d in fetched if not (d in seen or seen.add(d))]
+        log.info("CF proxy domain pool updated from GitHub (%d domains)", len(pool))
+    else:
+        pool = list(proxy_config.cfproxy_domains) or list(CFPROXY_DEFAULT_DOMAINS)
+
+    proxy_config.cfproxy_domains = pool
+    proxy_config.active_cfproxy_domain = random.choice(pool)
+
+
+def start_cfproxy_domain_refresh() -> None:
+    threading.Thread(
+        target=refresh_cfproxy_domains,
+        daemon=True,
+        name='cfproxy-domains-refresh',
+    ).start()
+
+
+def parse_dc_ip_list(dc_ip_list: List[str]) -> Dict[int, str]:
+    dc_redirects: Dict[int, str] = {}
+    for entry in dc_ip_list:
+        if ':' not in entry:
+            raise ValueError(
+                f"Invalid --dc-ip format {entry!r}, expected DC:IP")
+        dc_s, ip_s = entry.split(':', 1)
+        try:
+            dc_n = int(dc_s)
+            _socket.inet_aton(ip_s)
+        except (ValueError, OSError):
+            raise ValueError(f"Invalid --dc-ip {entry!r}")
+        dc_redirects[dc_n] = ip_s
+    return dc_redirects

proxy/crypto_backend.py

@@ -1,208 +0,0 @@
-from __future__ import annotations
-
-import os
-from typing import Protocol
-
-
-_SBOX = (
-    0x63, 0x7C, 0x77, 0x7B, 0xF2, 0x6B, 0x6F, 0xC5, 0x30, 0x01, 0x67, 0x2B,
-    0xFE, 0xD7, 0xAB, 0x76, 0xCA, 0x82, 0xC9, 0x7D, 0xFA, 0x59, 0x47, 0xF0,
-    0xAD, 0xD4, 0xA2, 0xAF, 0x9C, 0xA4, 0x72, 0xC0, 0xB7, 0xFD, 0x93, 0x26,
-    0x36, 0x3F, 0xF7, 0xCC, 0x34, 0xA5, 0xE5, 0xF1, 0x71, 0xD8, 0x31, 0x15,
-    0x04, 0xC7, 0x23, 0xC3, 0x18, 0x96, 0x05, 0x9A, 0x07, 0x12, 0x80, 0xE2,
-    0xEB, 0x27, 0xB2, 0x75, 0x09, 0x83, 0x2C, 0x1A, 0x1B, 0x6E, 0x5A, 0xA0,
-    0x52, 0x3B, 0xD6, 0xB3, 0x29, 0xE3, 0x2F, 0x84, 0x53, 0xD1, 0x00, 0xED,
-    0x20, 0xFC, 0xB1, 0x5B, 0x6A, 0xCB, 0xBE, 0x39, 0x4A, 0x4C, 0x58, 0xCF,
-    0xD0, 0xEF, 0xAA, 0xFB, 0x43, 0x4D, 0x33, 0x85, 0x45, 0xF9, 0x02, 0x7F,
-    0x50, 0x3C, 0x9F, 0xA8, 0x51, 0xA3, 0x40, 0x8F, 0x92, 0x9D, 0x38, 0xF5,
-    0xBC, 0xB6, 0xDA, 0x21, 0x10, 0xFF, 0xF3, 0xD2, 0xCD, 0x0C, 0x13, 0xEC,
-    0x5F, 0x97, 0x44, 0x17, 0xC4, 0xA7, 0x7E, 0x3D, 0x64, 0x5D, 0x19, 0x73,
-    0x60, 0x81, 0x4F, 0xDC, 0x22, 0x2A, 0x90, 0x88, 0x46, 0xEE, 0xB8, 0x14,
-    0xDE, 0x5E, 0x0B, 0xDB, 0xE0, 0x32, 0x3A, 0x0A, 0x49, 0x06, 0x24, 0x5C,
-    0xC2, 0xD3, 0xAC, 0x62, 0x91, 0x95, 0xE4, 0x79, 0xE7, 0xC8, 0x37, 0x6D,
-    0x8D, 0xD5, 0x4E, 0xA9, 0x6C, 0x56, 0xF4, 0xEA, 0x65, 0x7A, 0xAE, 0x08,
-    0xBA, 0x78, 0x25, 0x2E, 0x1C, 0xA6, 0xB4, 0xC6, 0xE8, 0xDD, 0x74, 0x1F,
-    0x4B, 0xBD, 0x8B, 0x8A, 0x70, 0x3E, 0xB5, 0x66, 0x48, 0x03, 0xF6, 0x0E,
-    0x61, 0x35, 0x57, 0xB9, 0x86, 0xC1, 0x1D, 0x9E, 0xE1, 0xF8, 0x98, 0x11,
-    0x69, 0xD9, 0x8E, 0x94, 0x9B, 0x1E, 0x87, 0xE9, 0xCE, 0x55, 0x28, 0xDF,
-    0x8C, 0xA1, 0x89, 0x0D, 0xBF, 0xE6, 0x42, 0x68, 0x41, 0x99, 0x2D, 0x0F,
-    0xB0, 0x54, 0xBB, 0x16,
-)
-_RCON = (0x01, 0x02, 0x04, 0x08, 0x10, 0x20, 0x40, 0x80, 0x1B, 0x36)
-
-
-class AesCtrTransform(Protocol):
-    def update(self, data: bytes) -> bytes:
-        ...
-
-    def finalize(self) -> bytes:
-        ...
-
-
-def _xtime(value: int) -> int:
-    value <<= 1
-    if value & 0x100:
-        value ^= 0x11B
-    return value & 0xFF
-
-
-def _mul2(value: int) -> int:
-    return _xtime(value)
-
-
-def _mul3(value: int) -> int:
-    return _xtime(value) ^ value
-
-
-def _add_round_key(state: list[int], round_key: bytes):
-    for idx in range(16):
-        state[idx] ^= round_key[idx]
-
-
-def _sub_bytes(state: list[int]):
-    for idx in range(16):
-        state[idx] = _SBOX[state[idx]]
-
-
-def _shift_rows(state: list[int]):
-    state[1], state[5], state[9], state[13] = (
-        state[5], state[9], state[13], state[1]
-    )
-    state[2], state[6], state[10], state[14] = (
-        state[10], state[14], state[2], state[6]
-    )
-    state[3], state[7], state[11], state[15] = (
-        state[15], state[3], state[7], state[11]
-    )
-
-
-def _mix_columns(state: list[int]):
-    for offset in range(0, 16, 4):
-        s0, s1, s2, s3 = state[offset:offset + 4]
-        state[offset + 0] = _mul2(s0) ^ _mul3(s1) ^ s2 ^ s3
-        state[offset + 1] = s0 ^ _mul2(s1) ^ _mul3(s2) ^ s3
-        state[offset + 2] = s0 ^ s1 ^ _mul2(s2) ^ _mul3(s3)
-        state[offset + 3] = _mul3(s0) ^ s1 ^ s2 ^ _mul2(s3)
-
-
-def _rot_word(word: list[int]) -> list[int]:
-    return word[1:] + word[:1]
-
-
-def _sub_word(word: list[int]) -> list[int]:
-    return [_SBOX[value] for value in word]
-
-
-def _expand_round_keys(key: bytes) -> tuple[list[bytes], int]:
-    if len(key) not in (16, 24, 32):
-        raise ValueError("AES key must be 16, 24, or 32 bytes long")
-
-    nk = len(key) // 4
-    nr = {4: 10, 6: 12, 8: 14}[nk]
-    words = [list(key[idx:idx + 4]) for idx in range(0, len(key), 4)]
-    total_words = 4 * (nr + 1)
-
-    for idx in range(nk, total_words):
-        temp = words[idx - 1][:]
-        if idx % nk == 0:
-            temp = _sub_word(_rot_word(temp))
-            temp[0] ^= _RCON[idx // nk - 1]
-        elif nk > 6 and idx % nk == 4:
-            temp = _sub_word(temp)
-        words.append([
-            words[idx - nk][byte_idx] ^ temp[byte_idx]
-            for byte_idx in range(4)
-        ])
-
-    round_keys = []
-    for round_idx in range(nr + 1):
-        start = round_idx * 4
-        round_keys.append(bytes(sum(words[start:start + 4], [])))
-    return round_keys, nr
-
-
-class _PurePythonAesCtrTransform:
-    def __init__(self, key: bytes, iv: bytes):
-        if len(iv) != 16:
-            raise ValueError("AES-CTR IV must be 16 bytes long")
-        self._round_keys, self._rounds = _expand_round_keys(key)
-        self._counter = bytearray(iv)
-        self._buffer = b""
-        self._buffer_offset = 0
-
-    def update(self, data: bytes) -> bytes:
-        if not data:
-            return b""
-
-        out = bytearray(len(data))
-        data_offset = 0
-
-        while data_offset < len(data):
-            if self._buffer_offset >= len(self._buffer):
-                self._buffer = self._encrypt_block(bytes(self._counter))
-                self._buffer_offset = 0
-                self._increment_counter()
-
-            available = len(self._buffer) - self._buffer_offset
-            chunk_size = min(len(data) - data_offset, available)
-            for chunk_idx in range(chunk_size):
-                out[data_offset + chunk_idx] = (
-                    data[data_offset + chunk_idx]
-                    ^ self._buffer[self._buffer_offset + chunk_idx]
-                )
-            data_offset += chunk_size
-            self._buffer_offset += chunk_size
-
-        return bytes(out)
-
-    def finalize(self) -> bytes:
-        return b""
-
-    def _encrypt_block(self, block: bytes) -> bytes:
-        state = list(block)
-        _add_round_key(state, self._round_keys[0])
-
-        for round_idx in range(1, self._rounds):
-            _sub_bytes(state)
-            _shift_rows(state)
-            _mix_columns(state)
-            _add_round_key(state, self._round_keys[round_idx])
-
-        _sub_bytes(state)
-        _shift_rows(state)
-        _add_round_key(state, self._round_keys[self._rounds])
-        return bytes(state)
-
-    def _increment_counter(self):
-        for idx in range(15, -1, -1):
-            self._counter[idx] = (self._counter[idx] + 1) & 0xFF
-            if self._counter[idx] != 0:
-                break
-
-
-def _create_cryptography_transform(key: bytes,
-                                   iv: bytes) -> AesCtrTransform:
-    from cryptography.hazmat.primitives.ciphers import Cipher, algorithms, modes
-
-    cipher = Cipher(algorithms.AES(key), modes.CTR(iv))
-    return cipher.encryptor()
-
-
-def create_aes_ctr_transform(key: bytes, iv: bytes,
-                             backend: str | None = None) -> AesCtrTransform:
-    """
-    Create a stateful AES-CTR transform.
-
-    Windows keeps using `cryptography` by default. Android can select the
-    pure-Python backend to avoid native build dependencies.
-    """
-    selected = backend or os.environ.get(
-        'TG_WS_PROXY_CRYPTO_BACKEND', 'cryptography')
-
-    if selected == 'cryptography':
-        return _create_cryptography_transform(key, iv)
-
-    if selected == 'python':
-        return _PurePythonAesCtrTransform(key, iv)
-
-    raise ValueError(f"Unsupported AES-CTR backend: {selected}")

proxy/raw_websocket.py

@@ -0,0 +1,239 @@
+import os
+import ssl
+import base64
+import struct
+import asyncio
+import socket as _socket
+
+from typing import List, Optional, Tuple
+from .config import proxy_config
+
+
+_st_BB = struct.Struct('>BB')
+_st_BBH = struct.Struct('>BBH')
+_st_BBQ = struct.Struct('>BBQ')
+_st_BB4s = struct.Struct('>BB4s')
+_st_BBH4s = struct.Struct('>BBH4s')
+_st_BBQ4s = struct.Struct('>BBQ4s')
+_st_H = struct.Struct('>H')
+_st_Q = struct.Struct('>Q')
+
+_ssl_ctx = ssl.create_default_context()
+_ssl_ctx.check_hostname = False
+_ssl_ctx.verify_mode = ssl.CERT_NONE
+
+
+class WsHandshakeError(Exception):
+    def __init__(self, status_code: int, status_line: str,
+                 headers: dict = None, location: str = None):
+        self.status_code = status_code
+        self.status_line = status_line
+        self.headers = headers or {}
+        self.location = location
+        super().__init__(f"HTTP {status_code}: {status_line}")
+
+    @property
+    def is_redirect(self) -> bool:
+        return self.status_code in (301, 302, 303, 307, 308)
+
+
+def _xor_mask(data: bytes, mask: bytes) -> bytes:
+    if not data:
+        return data
+    n = len(data)
+    mask_rep = (mask * (n // 4 + 1))[:n]
+    return (int.from_bytes(data, 'big') ^
+            int.from_bytes(mask_rep, 'big')).to_bytes(n, 'big')
+
+
+def set_sock_opts(transport, buffer_size):
+    sock = transport.get_extra_info('socket')
+    if sock is None:
+        return
+    
+    try:
+        sock.setsockopt(_socket.IPPROTO_TCP, _socket.TCP_NODELAY, 1)
+    except (OSError, AttributeError):
+        pass
+    
+    try:
+        sock.setsockopt(_socket.SOL_SOCKET, _socket.SO_RCVBUF, buffer_size)
+        sock.setsockopt(_socket.SOL_SOCKET, _socket.SO_SNDBUF, buffer_size)
+    except OSError:
+        pass
+
+
+class RawWebSocket:
+    __slots__ = ('reader', 'writer', '_closed')
+
+    OP_BINARY = 0x2
+    OP_CLOSE = 0x8
+    OP_PING = 0x9
+    OP_PONG = 0xA
+
+    def __init__(self, reader: asyncio.StreamReader,
+                 writer: asyncio.StreamWriter):
+        self.reader = reader
+        self.writer = writer
+        self._closed = False
+
+    @staticmethod
+    async def connect(host: str, domain: str, timeout: float = 10.0) -> 'RawWebSocket':
+        reader, writer = await asyncio.wait_for(
+            asyncio.open_connection(host, 443, ssl=_ssl_ctx,
+                                    server_hostname=domain),
+            timeout=min(timeout, 10))
+        
+        set_sock_opts(writer.transport, proxy_config.buffer_size)
+
+        ws_key = base64.b64encode(os.urandom(16)).decode()
+
+        req = (
+            f'GET /apiws HTTP/1.1\r\n'
+            f'Host: {domain}\r\n'
+            f'Upgrade: websocket\r\n'
+            f'Connection: Upgrade\r\n'
+            f'Sec-WebSocket-Key: {ws_key}\r\n'
+            f'Sec-WebSocket-Version: 13\r\n'
+            f'Sec-WebSocket-Protocol: binary\r\n'
+            f'User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64) '
+            f'AppleWebKit/537.36 (KHTML, like Gecko) '
+            f'Chrome/131.0.0.0 Safari/537.36\r\n'
+            f'\r\n'
+        )
+        writer.write(req.encode())
+        await writer.drain()
+
+        response_lines: list[str] = []
+        try:
+            while True:
+                line = await asyncio.wait_for(reader.readline(),
+                                              timeout=timeout)
+                if line in (b'\r\n', b'\n', b''):
+                    break
+                response_lines.append(
+                    line.decode('utf-8', errors='replace').strip())
+        except asyncio.TimeoutError:
+            writer.close()
+            raise
+
+        if not response_lines:
+            writer.close()
+            raise WsHandshakeError(0, 'empty response')
+
+        first_line = response_lines[0]
+        parts = first_line.split(' ', 2)
+        try:
+            status_code = int(parts[1]) if len(parts) >= 2 else 0
+        except ValueError:
+            status_code = 0
+
+        if status_code == 101:
+            return RawWebSocket(reader, writer)
+
+        headers: dict[str, str] = {}
+        for hl in response_lines[1:]:
+            if ':' in hl:
+                k, v = hl.split(':', 1)
+                headers[k.strip().lower()] = v.strip()
+
+        writer.close()
+        raise WsHandshakeError(status_code, first_line, headers,
+                                location=headers.get('location'))
+
+    async def send(self, data: bytes):
+        if self._closed:
+            raise ConnectionError("WebSocket closed")
+        frame = self._build_frame(self.OP_BINARY, data, mask=True)
+        self.writer.write(frame)
+        await self.writer.drain()
+
+    async def send_batch(self, parts: List[bytes]):
+        if self._closed:
+            raise ConnectionError("WebSocket closed")
+        for part in parts:
+            self.writer.write(
+                self._build_frame(self.OP_BINARY, part, mask=True))
+        await self.writer.drain()
+
+    async def recv(self) -> Optional[bytes]:
+        while not self._closed:
+            opcode, payload = await self._read_frame()
+
+            if opcode == self.OP_CLOSE:
+                self._closed = True
+                try:
+                    self.writer.write(self._build_frame(
+                        self.OP_CLOSE,
+                        payload[:2] if payload else b'', mask=True))
+                    await self.writer.drain()
+                except Exception:
+                    pass
+                return None
+
+            if opcode == self.OP_PING:
+                try:
+                    self.writer.write(
+                        self._build_frame(self.OP_PONG, payload, mask=True))
+                    await self.writer.drain()
+                except Exception:
+                    pass
+                continue
+
+            if opcode == self.OP_PONG:
+                continue
+
+            if opcode in (0x1, 0x2):
+                return payload
+            continue
+        return None
+
+    async def close(self):
+        if self._closed:
+            return
+        self._closed = True
+        try:
+            self.writer.write(
+                self._build_frame(self.OP_CLOSE, b'', mask=True))
+            await self.writer.drain()
+        except Exception:
+            pass
+        try:
+            self.writer.close()
+            await self.writer.wait_closed()
+        except Exception:
+            pass
+
+    @staticmethod
+    def _build_frame(opcode: int, data: bytes,
+                     mask: bool = False) -> bytes:
+        length = len(data)
+        fb = 0x80 | opcode
+        if not mask:
+            if length < 126:
+                return _st_BB.pack(fb, length) + data
+            if length < 65536:
+                return _st_BBH.pack(fb, 126, length) + data
+            return _st_BBQ.pack(fb, 127, length) + data
+        mask_key = os.urandom(4)
+        masked = _xor_mask(data, mask_key)
+        if length < 126:
+            return _st_BB4s.pack(fb, 0x80 | length, mask_key) + masked
+        if length < 65536:
+            return _st_BBH4s.pack(fb, 0x80 | 126, length, mask_key) + masked
+        return _st_BBQ4s.pack(fb, 0x80 | 127, length, mask_key) + masked
+
+    async def _read_frame(self) -> Tuple[int, bytes]:
+        hdr = await self.reader.readexactly(2)
+        opcode = hdr[0] & 0x0F
+        length = hdr[1] & 0x7F
+        if length == 126:
+            length = _st_H.unpack(await self.reader.readexactly(2))[0]
+        elif length == 127:
+            length = _st_Q.unpack(await self.reader.readexactly(8))[0]
+        if hdr[1] & 0x80:
+            mask_key = await self.reader.readexactly(4)
+            payload = await self.reader.readexactly(length)
+            return opcode, _xor_mask(payload, mask_key)
+        payload = await self.reader.readexactly(length)
+        return opcode, payload

proxy/stats.py

@@ -0,0 +1,33 @@
+from .utils import human_bytes
+
+class _Stats:
+    def __init__(self):
+        self.connections_total = 0
+        self.connections_active = 0
+        self.connections_ws = 0
+        self.connections_tcp_fallback = 0
+        self.connections_cfproxy = 0
+        self.connections_bad = 0
+        self.ws_errors = 0
+        self.bytes_up = 0
+        self.bytes_down = 0
+        self.pool_hits = 0
+        self.pool_misses = 0
+
+    def summary(self) -> str:
+        pool_total = self.pool_hits + self.pool_misses
+        pool_s = (f"{self.pool_hits}/{pool_total}"
+                  if pool_total else "n/a")
+        return (f"total={self.connections_total} "
+                f"active={self.connections_active} "
+                f"ws={self.connections_ws} "
+                f"tcp_fb={self.connections_tcp_fallback} "
+                f"cf={self.connections_cfproxy} "
+                f"bad={self.connections_bad} "
+                f"err={self.ws_errors} "
+                f"pool={pool_s} "
+                f"up={human_bytes(self.bytes_up)} "
+                f"down={human_bytes(self.bytes_down)}")
+
+
+stats = _Stats()

proxy/utils.py

@@ -0,0 +1,48 @@
+import socket as _socket
+
+from typing import Optional
+
+
+ZERO_64 = b'\x00' * 64
+HANDSHAKE_LEN = 64
+SKIP_LEN = 8
+PREKEY_LEN = 32
+KEY_LEN = 32
+IV_LEN = 16
+PROTO_TAG_POS = 56
+DC_IDX_POS = 60
+
+PROTO_TAG_ABRIDGED = b'\xef\xef\xef\xef'
+PROTO_TAG_INTERMEDIATE = b'\xee\xee\xee\xee'
+PROTO_TAG_SECURE = b'\xdd\xdd\xdd\xdd'
+
+PROTO_ABRIDGED_INT = 0xEFEFEFEF
+PROTO_INTERMEDIATE_INT = 0xEEEEEEEE
+PROTO_PADDED_INTERMEDIATE_INT = 0xDDDDDDDD
+
+RESERVED_FIRST_BYTES = {0xEF}
+RESERVED_STARTS = {b'\x48\x45\x41\x44', b'\x50\x4F\x53\x54',
+                    b'\x47\x45\x54\x20', b'\xee\xee\xee\xee',
+                    b'\xdd\xdd\xdd\xdd', b'\x16\x03\x01\x02'}
+RESERVED_CONTINUE = b'\x00\x00\x00\x00'
+
+
+def human_bytes(n: int) -> str:
+    for unit in ('B', 'KB', 'MB', 'GB'):
+        if abs(n) < 1024:
+            return f"{n:.1f}{unit}"
+        n /= 1024
+    return f"{n:.1f}TB"
+
+
+def get_link_host(host: str) -> Optional[str]:
+    if host == '0.0.0.0':
+        try:
+            with _socket.socket(_socket.AF_INET, _socket.SOCK_DGRAM) as _s:
+                _s.connect(('8.8.8.8', 80))
+                link_host = _s.getsockname()[0]
+        except OSError:
+            link_host = '127.0.0.1'
+        return link_host
+    else:
+        return host

pyproject.toml

@@ -7,7 +7,7 @@ name = "tg-ws-proxy"
 dynamic=["version"]
 
 description = "Telegram Desktop WebSocket Bridge Proxy"
-readme = "README.md"
+readme = "docs/README.md"
 requires-python = ">=3.8"
 
 license = { name = "MIT", file = "LICENSE" }
@@ -22,7 +22,7 @@ keywords = [
     "proxy",
     "bypass",
     "websocket",
-    "socks5",
+    "mtproto",
 ]
 classifiers = [
   "Development Status :: 5 - Production/Stable",
@@ -71,3 +71,6 @@ packages = ["proxy", "ui", "utils"]
 
 [tool.hatch.version]
 path = "proxy/__init__.py"
+
+[tool.ruff.lint]
+ignore = ["F403", "F405"]

tests/test_android_proxy_bridge.py

@@ -1,229 +0,0 @@
-import sys
-import unittest
-import json
-from pathlib import Path
-
-
-sys.path.insert(0, str(
-    Path(__file__).resolve().parents[1] / "android" / "app" / "src" / "main" / "python"
-))
-
-import android_proxy_bridge  # noqa: E402
-import proxy.tg_ws_proxy as tg_ws_proxy  # noqa: E402
-
-
-class FakeJavaArrayList:
-    def __init__(self, items):
-        self._items = list(items)
-
-    def size(self):
-        return len(self._items)
-
-    def get(self, index):
-        return self._items[index]
-
-
-class AndroidProxyBridgeTests(unittest.TestCase):
-    def tearDown(self):
-        tg_ws_proxy.reset_stats()
-        android_proxy_bridge._LAST_ERROR = None
-
-    def test_normalize_dc_ip_list_with_python_iterable(self):
-        result = android_proxy_bridge._normalize_dc_ip_list([
-            "2:149.154.167.220",
-            "  ",
-            "4:149.154.167.220 ",
-        ])
-
-        self.assertEqual(result, [
-            "2:149.154.167.220",
-            "4:149.154.167.220",
-        ])
-
-    def test_get_runtime_stats_json_reports_proxy_counters(self):
-        tg_ws_proxy.reset_stats()
-        snapshot = tg_ws_proxy.get_stats_snapshot()
-        snapshot["bytes_up"] = 1536
-        snapshot["bytes_down"] = 4096
-        tg_ws_proxy._stats.bytes_up = snapshot["bytes_up"]
-        tg_ws_proxy._stats.bytes_down = snapshot["bytes_down"]
-
-        result = json.loads(android_proxy_bridge.get_runtime_stats_json())
-
-        self.assertEqual(result["bytes_up"], 1536)
-        self.assertEqual(result["bytes_down"], 4096)
-        self.assertFalse(result["running"])
-        self.assertIsNone(result["last_error"])
-
-    def test_get_runtime_stats_json_includes_last_error(self):
-        android_proxy_bridge._LAST_ERROR = "boom"
-
-        result = json.loads(android_proxy_bridge.get_runtime_stats_json())
-
-        self.assertEqual(result["last_error"], "boom")
-
-    def test_normalize_dc_ip_list_with_java_array_list_shape(self):
-        result = android_proxy_bridge._normalize_dc_ip_list(FakeJavaArrayList([
-            "2:149.154.167.220",
-            "4:149.154.167.220",
-        ]))
-
-        self.assertEqual(result, [
-            "2:149.154.167.220",
-            "4:149.154.167.220",
-        ])
-
-    def test_start_proxy_saves_advanced_runtime_config(self):
-        captured = {}
-
-        class FakeRuntime:
-            def __init__(self, *args, **kwargs):
-                captured["runtime_init"] = kwargs
-                self.log_file = Path("/tmp/proxy.log")
-
-            def reset_log_file(self):
-                captured["reset_log_file"] = True
-
-            def setup_logging(self, verbose=False, log_max_mb=5):
-                captured["verbose"] = verbose
-                captured["log_max_mb"] = log_max_mb
-
-            def save_config(self, config):
-                captured["config"] = dict(config)
-
-            def start_proxy(self, config):
-                captured["start_proxy"] = dict(config)
-                return True
-
-            def is_proxy_running(self):
-                return True
-
-            def stop_proxy(self):
-                captured["stop_proxy"] = True
-
-        original_runtime = android_proxy_bridge.ProxyAppRuntime
-        try:
-            android_proxy_bridge.ProxyAppRuntime = FakeRuntime
-            log_path = android_proxy_bridge.start_proxy(
-                "/tmp/app",
-                "127.0.0.1",
-                1080,
-                ["2:149.154.167.220"],
-                7.0,
-                512,
-                6,
-                True,
-            )
-        finally:
-            android_proxy_bridge.ProxyAppRuntime = original_runtime
-
-        self.assertEqual(log_path, "/tmp/proxy.log")
-        self.assertEqual(captured["config"]["log_max_mb"], 7.0)
-        self.assertEqual(captured["config"]["buf_kb"], 512)
-        self.assertEqual(captured["config"]["pool_size"], 6)
-        self.assertEqual(captured["log_max_mb"], 7.0)
-        self.assertTrue(captured["verbose"])
-
-    def test_get_update_status_json_merges_python_update_state(self):
-        original_load_update_check = android_proxy_bridge._load_update_check
-        try:
-            captured = {}
-
-            class FakeUpdateCheck:
-                RELEASES_PAGE_URL = "https://example.com/releases/latest"
-
-                @staticmethod
-                def run_check(version):
-                    captured["run_check_version"] = version
-
-                @staticmethod
-                def get_status():
-                    return {
-                        "checked": True,
-                        "latest": "1.3.1",
-                        "has_update": True,
-                        "ahead_of_release": False,
-                        "html_url": "https://example.com/release",
-                        "error": "",
-                    }
-
-            android_proxy_bridge._load_update_check = lambda: FakeUpdateCheck
-            result = json.loads(android_proxy_bridge.get_update_status_json(True))
-        finally:
-            android_proxy_bridge._load_update_check = original_load_update_check
-
-        self.assertEqual(captured["run_check_version"], android_proxy_bridge.__version__)
-        self.assertEqual(result["current_version"], android_proxy_bridge.__version__)
-        self.assertEqual(result["latest"], "1.3.1")
-        self.assertTrue(result["has_update"])
-        self.assertTrue(result["checked"])
-        self.assertEqual(result["html_url"], "https://example.com/release")
-
-    def test_get_update_status_json_reports_unchecked_state(self):
-        original_load_update_check = android_proxy_bridge._load_update_check
-        try:
-            class FakeUpdateCheck:
-                RELEASES_PAGE_URL = "https://example.com/releases/latest"
-
-                @staticmethod
-                def get_status():
-                    return {
-                        "checked": False,
-                        "latest": "",
-                        "has_update": False,
-                        "ahead_of_release": False,
-                        "html_url": "",
-                        "error": "",
-                    }
-
-            android_proxy_bridge._load_update_check = lambda: FakeUpdateCheck
-            result = json.loads(android_proxy_bridge.get_update_status_json(False))
-        finally:
-            android_proxy_bridge._load_update_check = original_load_update_check
-
-        self.assertFalse(result["checked"])
-        self.assertEqual(result["current_version"], android_proxy_bridge.__version__)
-
-    def test_get_update_status_json_reports_import_error_without_breaking_bridge(self):
-        original_load_update_check = android_proxy_bridge._load_update_check
-        try:
-            def fail():
-                raise ModuleNotFoundError("No module named 'utils'")
-
-            android_proxy_bridge._load_update_check = fail
-            result = json.loads(android_proxy_bridge.get_update_status_json(True))
-        finally:
-            android_proxy_bridge._load_update_check = original_load_update_check
-
-        self.assertFalse(result["checked"])
-        self.assertIn("No module named 'utils'", result["error"])
-
-    def test_get_update_status_json_normalizes_none_fields_for_kotlin(self):
-        original_load_update_check = android_proxy_bridge._load_update_check
-        try:
-            class FakeUpdateCheck:
-                RELEASES_PAGE_URL = "https://example.com/releases/latest"
-
-                @staticmethod
-                def get_status():
-                    return {
-                        "checked": True,
-                        "latest": None,
-                        "has_update": False,
-                        "ahead_of_release": True,
-                        "html_url": None,
-                        "error": None,
-                    }
-
-            android_proxy_bridge._load_update_check = lambda: FakeUpdateCheck
-            result = json.loads(android_proxy_bridge.get_update_status_json(False))
-        finally:
-            android_proxy_bridge._load_update_check = original_load_update_check
-
-        self.assertEqual(result["latest"], "")
-        self.assertEqual(result["error"], "")
-        self.assertEqual(result["html_url"], "https://example.com/releases/latest")
-
-
-if __name__ == "__main__":
-    unittest.main()

tests/test_app_runtime.py

@@ -1,121 +0,0 @@
-import json
-import tempfile
-import unittest
-from pathlib import Path
-
-from proxy.app_runtime import DEFAULT_CONFIG, ProxyAppRuntime
-
-
-class _FakeThread:
-    def __init__(self, target=None, args=(), daemon=None, name=None):
-        self.target = target
-        self.args = args
-        self.daemon = daemon
-        self.name = name
-        self.started = False
-        self.join_timeout = None
-        self._alive = False
-
-    def start(self):
-        self.started = True
-        self._alive = True
-
-    def is_alive(self):
-        return self._alive
-
-    def join(self, timeout=None):
-        self.join_timeout = timeout
-        self._alive = False
-
-
-class ProxyAppRuntimeTests(unittest.TestCase):
-    def test_load_config_returns_defaults_when_missing(self):
-        with tempfile.TemporaryDirectory() as tmpdir:
-            runtime = ProxyAppRuntime(Path(tmpdir))
-
-            cfg = runtime.load_config()
-
-            self.assertEqual(cfg, DEFAULT_CONFIG)
-
-    def test_load_config_merges_defaults_into_saved_config(self):
-        with tempfile.TemporaryDirectory() as tmpdir:
-            app_dir = Path(tmpdir)
-            config_path = app_dir / "config.json"
-            app_dir.mkdir(parents=True, exist_ok=True)
-            config_path.write_text(
-                json.dumps({"port": 9050, "host": "127.0.0.2"}),
-                encoding="utf-8")
-            runtime = ProxyAppRuntime(app_dir)
-
-            cfg = runtime.load_config()
-
-            self.assertEqual(cfg["port"], 9050)
-            self.assertEqual(cfg["host"], "127.0.0.2")
-            self.assertEqual(cfg["dc_ip"], DEFAULT_CONFIG["dc_ip"])
-            self.assertEqual(cfg["verbose"], DEFAULT_CONFIG["verbose"])
-
-    def test_invalid_config_file_falls_back_to_defaults(self):
-        with tempfile.TemporaryDirectory() as tmpdir:
-            app_dir = Path(tmpdir)
-            app_dir.mkdir(parents=True, exist_ok=True)
-            (app_dir / "config.json").write_text("{broken", encoding="utf-8")
-            runtime = ProxyAppRuntime(app_dir)
-
-            cfg = runtime.load_config()
-
-            self.assertEqual(cfg, DEFAULT_CONFIG)
-
-    def test_start_proxy_starts_thread_with_parsed_dc_options(self):
-        with tempfile.TemporaryDirectory() as tmpdir:
-            captured = {}
-            thread_holder = {}
-
-            def fake_parse(entries):
-                captured["dc_ip"] = list(entries)
-                return {2: "149.154.167.220"}
-
-            def fake_thread_factory(**kwargs):
-                thread = _FakeThread(**kwargs)
-                thread_holder["thread"] = thread
-                return thread
-
-            runtime = ProxyAppRuntime(
-                Path(tmpdir),
-                parse_dc_ip_list=fake_parse,
-                thread_factory=fake_thread_factory)
-
-            started = runtime.start_proxy(dict(DEFAULT_CONFIG))
-
-            self.assertTrue(started)
-            self.assertEqual(captured["dc_ip"], DEFAULT_CONFIG["dc_ip"])
-            self.assertTrue(thread_holder["thread"].started)
-            self.assertEqual(
-                thread_holder["thread"].args,
-                (DEFAULT_CONFIG["port"], {2: "149.154.167.220"},
-                 DEFAULT_CONFIG["host"]))
-
-    def test_start_proxy_reports_bad_config(self):
-        with tempfile.TemporaryDirectory() as tmpdir:
-            errors = []
-
-            def fake_parse(entries):
-                raise ValueError("bad dc mapping")
-
-            runtime = ProxyAppRuntime(
-                Path(tmpdir),
-                parse_dc_ip_list=fake_parse,
-                on_error=errors.append)
-
-            started = runtime.start_proxy({
-                "host": "127.0.0.1",
-                "port": 1080,
-                "dc_ip": ["broken"],
-                "verbose": False,
-            })
-
-            self.assertFalse(started)
-            self.assertEqual(errors, ["Ошибка конфигурации:\nbad dc mapping"])
-
-
-if __name__ == "__main__":
-    unittest.main()

tests/test_crypto_mtproto.py

@@ -1,107 +0,0 @@
-import struct
-import unittest
-
-from proxy.crypto_backend import create_aes_ctr_transform
-from proxy.tg_ws_proxy import _MsgSplitter, _dc_from_init, _patch_init_dc
-
-
-KEY = bytes(range(32))
-IV = bytes(range(16))
-PROTO_TAG = 0xEFEFEFEF
-
-
-def _xor(left: bytes, right: bytes) -> bytes:
-    return bytes(a ^ b for a, b in zip(left, right))
-
-
-def _keystream(size: int) -> bytes:
-    transform = create_aes_ctr_transform(KEY, IV)
-    return transform.update(b"\x00" * size) + transform.finalize()
-
-
-def _build_init_packet(dc_raw: int, proto: int = PROTO_TAG) -> bytes:
-    packet = bytearray(64)
-    packet[8:40] = KEY
-    packet[40:56] = IV
-
-    plain_tail = struct.pack("<Ih", proto, dc_raw) + b"\x00\x00"
-    packet[56:64] = _xor(plain_tail, _keystream(64)[56:64])
-    return bytes(packet)
-
-
-def _encrypt_after_init(init_packet: bytes, plaintext: bytes) -> bytes:
-    transform = create_aes_ctr_transform(init_packet[8:40], init_packet[40:56])
-    transform.update(b"\x00" * 64)
-    return transform.update(plaintext) + transform.finalize()
-
-
-class CryptoBackendTests(unittest.TestCase):
-    def test_python_backend_matches_cryptography_stream(self):
-        cryptography_transform = create_aes_ctr_transform(
-            KEY, IV, backend="cryptography")
-        python_transform = create_aes_ctr_transform(KEY, IV, backend="python")
-
-        chunks = [
-            b"",
-            b"\x00" * 16,
-            bytes(range(31)),
-            b"telegram-proxy",
-            b"\xff" * 64,
-        ]
-
-        cryptography_out = b"".join(
-            cryptography_transform.update(chunk) for chunk in chunks
-        ) + cryptography_transform.finalize()
-        python_out = b"".join(
-            python_transform.update(chunk) for chunk in chunks
-        ) + python_transform.finalize()
-
-        self.assertEqual(python_out, cryptography_out)
-
-    def test_unknown_backend_raises_error(self):
-        with self.assertRaises(ValueError):
-            create_aes_ctr_transform(KEY, IV, backend="missing")
-
-
-class MtProtoInitTests(unittest.TestCase):
-    def test_dc_from_init_reads_non_media_dc(self):
-        init_packet = _build_init_packet(dc_raw=2)
-
-        self.assertEqual(_dc_from_init(init_packet), (2, False))
-
-    def test_dc_from_init_reads_media_dc(self):
-        init_packet = _build_init_packet(dc_raw=-4)
-
-        self.assertEqual(_dc_from_init(init_packet), (4, True))
-
-    def test_patch_init_dc_updates_signed_dc_and_preserves_tail(self):
-        original = _build_init_packet(dc_raw=99) + b"tail"
-
-        patched = _patch_init_dc(original, -3)
-
-        self.assertEqual(_dc_from_init(patched[:64]), (3, True))
-        self.assertEqual(patched[64:], b"tail")
-
-
-class MsgSplitterTests(unittest.TestCase):
-    def test_splitter_splits_multiple_abridged_messages(self):
-        init_packet = _build_init_packet(dc_raw=-2)
-        plain_chunk = b"\x01abcd\x02EFGH1234"
-        encrypted_chunk = _encrypt_after_init(init_packet, plain_chunk)
-
-        parts = _MsgSplitter(init_packet).split(encrypted_chunk)
-
-        self.assertEqual(parts, [encrypted_chunk[:5], encrypted_chunk[5:14]])
-
-    def test_splitter_leaves_single_message_intact(self):
-        init_packet = _build_init_packet(dc_raw=2)
-        plain_chunk = b"\x02abcdefgh"
-        encrypted_chunk = _encrypt_after_init(init_packet, plain_chunk)
-
-        parts = _MsgSplitter(init_packet).split(encrypted_chunk)
-
-        self.assertEqual(parts, [encrypted_chunk])
-
-
-if __name__ == "__main__":
-    unittest.main()

tests/test_socks5_protocol.py

@@ -1,129 +0,0 @@
-import asyncio
-import socket
-import unittest
-from unittest.mock import patch
-
-from proxy.tg_ws_proxy import _handle_client, _socks5_reply
-
-
-class _FakeTransport:
-    def get_extra_info(self, name):
-        return None
-
-    def get_write_buffer_size(self):
-        return 0
-
-
-class _FakeReader:
-    def __init__(self, payload: bytes):
-        self._payload = payload
-        self._offset = 0
-
-    async def readexactly(self, n: int) -> bytes:
-        end = self._offset + n
-        if end > len(self._payload):
-            partial = self._payload[self._offset:]
-            self._offset = len(self._payload)
-            raise asyncio.IncompleteReadError(partial, n)
-        chunk = self._payload[self._offset:end]
-        self._offset = end
-        return chunk
-
-
-class _FakeWriter:
-    def __init__(self):
-        self.transport = _FakeTransport()
-        self.writes = []
-        self.closed = False
-        self.close_calls = 0
-
-    def get_extra_info(self, name):
-        if name == "peername":
-            return ("127.0.0.1", 50000)
-        return None
-
-    def write(self, data: bytes):
-        self.writes.append(data)
-
-    async def drain(self):
-        return None
-
-    def close(self):
-        self.closed = True
-        self.close_calls += 1
-
-    async def wait_closed(self):
-        return None
-
-
-def _ipv4_connect_request(ip: str, port: int, cmd: int = 1) -> bytes:
-    return bytes([0x05, cmd, 0x00, 0x01]) + socket.inet_aton(ip) + port.to_bytes(2, "big")
-
-
-def _domain_connect_request(domain: str, port: int, cmd: int = 1) -> bytes:
-    encoded = domain.encode("utf-8")
-    return (
-        bytes([0x05, cmd, 0x00, 0x03, len(encoded)])
-        + encoded
-        + port.to_bytes(2, "big")
-    )
-
-
-def _ipv6_connect_request(ip: str, port: int) -> bytes:
-    return (
-        bytes([0x05, 0x01, 0x00, 0x04])
-        + socket.inet_pton(socket.AF_INET6, ip)
-        + port.to_bytes(2, "big")
-    )
-
-
-class Socks5ProtocolTests(unittest.IsolatedAsyncioTestCase):
-    async def test_rejects_non_socks5_greeting(self):
-        reader = _FakeReader(b"\x04\x01")
-        writer = _FakeWriter()
-
-        await _handle_client(reader, writer)
-
-        self.assertEqual(writer.writes, [])
-        self.assertTrue(writer.closed)
-
-    async def test_rejects_unsupported_command(self):
-        reader = _FakeReader(b"\x05\x01\x00" + _ipv4_connect_request("1.1.1.1", 443, cmd=2))
-        writer = _FakeWriter()
-
-        await _handle_client(reader, writer)
-
-        self.assertEqual(writer.writes, [b"\x05\x00", _socks5_reply(0x07)])
-        self.assertTrue(writer.closed)
-
-    async def test_rejects_unsupported_address_type(self):
-        reader = _FakeReader(b"\x05\x01\x00" + b"\x05\x01\x00\x02")
-        writer = _FakeWriter()
-
-        await _handle_client(reader, writer)
-
-        self.assertEqual(writer.writes, [b"\x05\x00", _socks5_reply(0x08)])
-        self.assertTrue(writer.closed)
-
-    async def test_rejects_ipv6_destinations(self):
-        reader = _FakeReader(b"\x05\x01\x00" + _ipv6_connect_request("2001:db8::1", 443))
-        writer = _FakeWriter()
-
-        await _handle_client(reader, writer)
-
-        self.assertEqual(writer.writes, [b"\x05\x00", _socks5_reply(0x05)])
-        self.assertTrue(writer.closed)
-
-    async def test_passthrough_connect_failure_returns_error(self):
-        reader = _FakeReader(b"\x05\x01\x00" + _domain_connect_request("example.com", 443))
-        writer = _FakeWriter()
-
-        with patch("proxy.tg_ws_proxy.asyncio.open_connection", side_effect=OSError("boom")):
-            await _handle_client(reader, writer)
-
-        self.assertEqual(writer.writes, [b"\x05\x00", _socks5_reply(0x05)])
-        self.assertTrue(writer.closed)
-
-
-if __name__ == "__main__":
-    unittest.main()

tests/test_update_check.py

@@ -1,53 +0,0 @@
-import unittest
-
-from utils import update_check
-
-
-class UpdateCheckTests(unittest.TestCase):
-    def setUp(self):
-        self._orig_state = dict(update_check._state)
-
-    def tearDown(self):
-        update_check._state.clear()
-        update_check._state.update(self._orig_state)
-
-    def test_apply_release_tag_marks_update_available(self):
-        update_check._apply_release_tag(
-            tag="v1.3.1",
-            html_url="https://example.com/release",
-            current_version="1.3.0",
-        )
-
-        status = update_check.get_status()
-        self.assertTrue(status["has_update"])
-        self.assertFalse(status["ahead_of_release"])
-        self.assertEqual(status["latest"], "1.3.1")
-        self.assertEqual(status["html_url"], "https://example.com/release")
-
-    def test_apply_release_tag_marks_ahead_of_release(self):
-        update_check._apply_release_tag(
-            tag="v1.1.2-relay",
-            html_url="https://example.com/release",
-            current_version="1.3.0",
-        )
-
-        status = update_check.get_status()
-        self.assertFalse(status["has_update"])
-        self.assertTrue(status["ahead_of_release"])
-        self.assertEqual(status["latest"], "1.1.2-relay")
-
-    def test_apply_release_tag_marks_latest_when_versions_match(self):
-        update_check._apply_release_tag(
-            tag="v1.3.0",
-            html_url="https://example.com/release",
-            current_version="1.3.0",
-        )
-
-        status = update_check.get_status()
-        self.assertFalse(status["has_update"])
-        self.assertFalse(status["ahead_of_release"])
-        self.assertEqual(status["latest"], "1.3.0")
-
-
-if __name__ == "__main__":
-    unittest.main()

ui/ctk_theme.py

@@ -1,8 +1,3 @@
-"""
-Общая светлая тема и фабрика окон CustomTkinter для tray-приложений (Windows / Linux).
-Цвета и отступы задаются в одном месте — правки темы не дублируются по платформам.
-"""
-
 from __future__ import annotations
 
 import sys
@@ -13,11 +8,7 @@ from typing import Any, Callable, Optional, Tuple
 _tk_variable_del_guard_installed = False
 
 
-def _install_tkinter_variable_del_guard() -> None:
+def install_tkinter_variable_del_guard() -> None:
-    """
-    Убирает «Exception ignored» при выходе процесса: Tcl уже разрушен, а GC ещё
-    вызывает Variable.__del__ (StringVar и т.д.) — напр. окно CTk в фоновом потоке.
-    """
     global _tk_variable_del_guard_installed
     if _tk_variable_del_guard_installed:
         return
@@ -32,24 +23,24 @@ def _install_tkinter_variable_del_guard() -> None:
     tkinter.Variable.__del__ = _safe_variable_del  # type: ignore[assignment]
     _tk_variable_del_guard_installed = True
 
-# Размеры и отступы (единые для диалогов настроек и первого запуска)
 CONFIG_DIALOG_SIZE: Tuple[int, int] = (460, 560)
 CONFIG_DIALOG_FRAME_PAD: Tuple[int, int] = (20, 14)
-FIRST_RUN_SIZE: Tuple[int, int] = (520, 440)
+FIRST_RUN_SIZE: Tuple[int, int] = (520, 480)
 FIRST_RUN_FRAME_PAD: Tuple[int, int] = (28, 24)
 
 
 @dataclass(frozen=True)
 class CtkTheme:
-    """Палитра Telegram-style и семейства шрифтов для UI и моноширинного текста."""
+    tg_blue: tuple = ("#3390ec", "#3390ec")
+    tg_blue_hover: tuple = ("#2b7cd4", "#2b7cd4")
+
+    bg: tuple = ("#ffffff", "#1e1e1e")
+    field_bg: tuple = ("#f0f2f5", "#2b2b2b")
+    field_border: tuple = ("#d6d9dc", "#3a3a3a")
+
+    text_primary: tuple = ("#000000", "#ffffff")
+    text_secondary: tuple = ("#707579", "#aaaaaa")
 
-    tg_blue: str = "#3390ec"
-    tg_blue_hover: str = "#2b7cd4"
-    bg: str = "#ffffff"
-    field_bg: str = "#f0f2f5"
-    field_border: str = "#d6d9dc"
-    text_primary: str = "#000000"
-    text_secondary: str = "#707579"
     ui_font_family: str = "Sans"
     mono_font_family: str = "Monospace"
 
@@ -60,18 +51,20 @@ def ctk_theme_for_platform() -> CtkTheme:
     return CtkTheme()
 
 
-def apply_ctk_appearance(ctk: Any) -> None:
+_APPEARANCE_MODE_MAP = {"auto": "system", "light": "Light", "dark": "Dark"}
-    ctk.set_appearance_mode("light")
-    ctk.set_default_color_theme("blue")
 
 
+def apply_ctk_appearance(ctk: Any, mode: str = "auto") -> None:
+    ctk.set_appearance_mode(_APPEARANCE_MODE_MAP.get(mode, "system"))
+    ctk.set_default_color_theme("blue")
+
 def center_ctk_geometry(root: Any, width: int, height: int) -> None:
     sw = root.winfo_screenwidth()
     sh = root.winfo_screenheight()
     root.geometry(f"{width}x{height}+{(sw - width) // 2}+{(sh - height) // 2}")
 
 
-def create_ctk_root(
+def create_ctk_toplevel(
     ctk: Any,
     *,
     title: str,
@@ -81,21 +74,27 @@ def create_ctk_root(
     topmost: bool = True,
     after_create: Optional[Callable[[Any], None]] = None,
 ) -> Any:
-    """
+    root = ctk.CTkToplevel()
-    Создаёт CTk: глобальная тема, заголовок, без ресайза, по центру экрана, фон из палитры.
-    after_create — опционально: установка иконки окна (различается по ОС).
-    """
-    _install_tkinter_variable_del_guard()
-    apply_ctk_appearance(ctk)
-    root = ctk.CTk()
     root.title(title)
     root.resizable(False, False)
-    if topmost:
-        root.attributes("-topmost", True)
     center_ctk_geometry(root, width, height)
     root.configure(fg_color=theme.bg)
+    if topmost:
+        root.attributes("-topmost", True)
+    root.lift()
+    root.focus_force()
     if after_create:
-        after_create(root)
+        _after_id = root.after(300, lambda: after_create(root))
+        _orig_destroy = root.destroy
+
+        def _safe_destroy():
+            try:
+                root.after_cancel(_after_id)
+            except Exception:
+                pass
+            _orig_destroy()
+
+        root.destroy = _safe_destroy
     return root
 
 
@@ -109,4 +108,4 @@ def main_content_frame(
 ) -> Any:
     frame = ctk.CTkFrame(root, fg_color=theme.bg, corner_radius=0)
     frame.pack(fill="both", expand=True, padx=padx, pady=pady)
-    return frame
+    return frame

ui/ctk_tooltip.py

@@ -1,7 +1,3 @@
-"""
-Всплывающие подсказки для CustomTkinter / tk: задержка, Toplevel без рамки, wrap.
-"""
-
 from __future__ import annotations
 
 import tkinter as tk
@@ -9,8 +5,6 @@ from typing import Any, List, Optional
 
 
 class CtkTooltip:
-    """Показ текста при наведении на виджет."""
-
     def __init__(
         self,
         widget: Any,
@@ -31,6 +25,8 @@ class CtkTooltip:
         widget.bind("<Destroy>", self._on_destroy, add="+")
 
     def _schedule(self, _event: Any = None) -> None:
+        if self.widget is None:
+            return
         self._cancel_after()
         self._after_id = self.widget.after(self.delay_ms, self._show)
 
@@ -89,6 +85,7 @@ class CtkTooltip:
 
     def _on_destroy(self, _event: Any = None) -> None:
         self._hide()
+        self.widget = None
 
 
 def _is_windows() -> bool:
@@ -104,11 +101,9 @@ def attach_ctk_tooltip(
     delay_ms: int = 450,
     wraplength: int = 320,
 ) -> None:
-    """Повесить подсказку на виджет (CTk или tk)."""
     CtkTooltip(widget, text, delay_ms=delay_ms, wraplength=wraplength)
 
 
 def attach_tooltip_to_widgets(widgets: List[Any], text: str, **kwargs: Any) -> None:
-    """Одна и та же подсказка на несколько виджетов (подпись + поле)."""
     for w in widgets:
         attach_ctk_tooltip(w, text, **kwargs)

ui/ctk_tray_ui.py

@@ -1,18 +1,15 @@
-"""
-Общая разметка CustomTkinter для tray (Windows / Linux): настройки и первый запуск.
-Логика сохранения и колбэки остаются в платформенных модулях.
-"""
-
 from __future__ import annotations
 
+import os
 import webbrowser
 from dataclasses import dataclass
 from typing import Any, Callable, Dict, List, Optional, Tuple, Union
 
-import proxy.tg_ws_proxy as tg_ws_proxy
+from proxy import __version__, get_link_host, parse_dc_ip_list
-from proxy import __version__
+from proxy.config import CFPROXY_DEFAULT_DOMAINS
 from utils.update_check import RELEASES_PAGE_URL, get_status
 
+
 from ui.ctk_theme import (
     FIRST_RUN_FRAME_PAD,
     CtkTheme,
@@ -20,19 +17,20 @@ from ui.ctk_theme import (
 )
 from ui.ctk_tooltip import attach_ctk_tooltip, attach_tooltip_to_widgets
 
-# Подсказки для формы настроек (новые пользователи)
 _TIP_HOST = (
-    "Адрес, на котором прокси принимает SOCKS5-подключения.\n"
+    "Адрес, на котором прокси принимает подключения.\n"
     "Обычно 127.0.0.1 — локальная сеть, 0.0.0.0 - все интерфейсы"
 )
 _TIP_PORT = (
-    "Порт SOCKS5. В Telegram Desktop в настройках прокси должен быть "
+    "Порт прокси. В Telegram Desktop в настройках прокси должен быть "
     "указан тот же порт"
 )
+_TIP_SECRET = "Секретный ключ для авторизации клиентов"
 _TIP_DC = (
     "Соответствие номера датацентра Telegram (DC) и IP-адреса сервера.\n"
-    "Каждая строка: «номер:IP», например 2:149.154.167.220. "
+    "Каждая строка: «номер:IP», например 4:149.154.167.220. "
-    "Прокси по этим правилам направляет трафик к нужным серверам Telegram"
+    "Прокси по этим правилам направляет трафик к нужным серверам Telegram\n\n"
+    "Если у вас не работают медиа и работает CF-прокси, то попробуйте убрать строку 2:149.154.167.220"
 )
 _TIP_VERBOSE = (
     "Если включено, в файл логов пишется больше подробностей — "
@@ -53,14 +51,192 @@ _TIP_AUTOSTART = (
     "Запускать TG WS Proxy при входе в Windows. "
     "Если вы переместите программу в другую папку, автозапуск сбросится"
 )
-_TIP_CHECK_UPDATES = (
+_TIP_CHECK_UPDATES = "При запуске проверять наличие обновлений"
-    "При запуске проверять наличие обновлений"
+_TIP_CFPROXY = (
+    "Использовать Cloudflare прокси для недоступных датацентров"
+)
+_TIP_CFPROXY_PRIORITY = (
+    "Пробовать CF-прокси раньше прямого TCP-подключения"
+)
+_TIP_CFPROXY_DOMAIN = (
+    "Ваш собственный домен, проксируемый через Cloudflare, для WS-подключения.\n"
+    "Если не указан — выбирается автоматически из поддерживаемых доменов"
+)
+_TIP_CFPROXY_USER_DOMAIN_CB = (
+    "Указать свой домен вместо автоматического выбора"
 )
 _TIP_SAVE = "Сохранить настройки"
 _TIP_CANCEL = "Закрыть окно без сохранения изменений"
 
-# Внутренняя ширина полей относительно ширины окна настроек (см. CONFIG_DIALOG_SIZE)
+_CFPROXY_HELP_URL = "https://github.com/Flowseal/tg-ws-proxy/blob/main/docs/CfProxy.md"
-_CONFIG_FORM_INNER_WIDTH = 396
+_CFPROXY_TEST_DCS = [1, 2, 3, 4, 5, 203]
+
+
+def _run_cfproxy_connectivity_test(domain: str) -> dict:
+    import base64
+    import ssl
+    import socket as _socket
+
+    ctx = ssl.create_default_context()
+    ctx.check_hostname = False
+    ctx.verify_mode = ssl.CERT_NONE
+    results = {}
+    for dc in _CFPROXY_TEST_DCS:
+        host = f"kws{dc}.{domain}"
+        try:
+            with _socket.create_connection((host, 443), timeout=5) as raw:
+                with ctx.wrap_socket(raw, server_hostname=host) as ssock:
+                    ws_key = base64.b64encode(os.urandom(16)).decode()
+                    req = (
+                        f"GET /apiws HTTP/1.1\r\n"
+                        f"Host: {host}\r\n"
+                        f"Upgrade: websocket\r\n"
+                        f"Connection: Upgrade\r\n"
+                        f"Sec-WebSocket-Key: {ws_key}\r\n"
+                        f"Sec-WebSocket-Version: 13\r\n"
+                        f"Sec-WebSocket-Protocol: binary\r\n"
+                        f"\r\n"
+                    ).encode()
+                    ssock.sendall(req)
+                    ssock.settimeout(5)
+                    buf = b""
+                    while b"\r\n\r\n" not in buf:
+                        chunk = ssock.recv(512)
+                        if not chunk:
+                            break
+                        buf += chunk
+                    first = buf.decode("utf-8", errors="replace").split("\r\n")[0]
+                    if "101" in first:
+                        results[dc] = True
+                    else:
+                        results[dc] = first or "нет ответа"
+                    ssock.close()
+                raw.close()
+        except _socket.timeout:
+            results[dc] = "таймаут"
+        except OSError as exc:
+            msg = str(exc)
+            results[dc] = msg[:60] if len(msg) > 60 else msg
+    return results
+
+
+def _run_cfproxy_auto_test(domains: list) -> tuple:
+    last: dict = {}
+    for domain in domains:
+        res = _run_cfproxy_connectivity_test(domain)
+        last = res
+        if any(v is True for v in res.values()):
+            return domain, res
+    return None, last
+
+
+def _cfproxy_show_test_results(domain: str, results: dict) -> None:
+    import tkinter as _tk
+    from tkinter import messagebox as _mb
+
+    ok = [dc for dc, v in results.items() if v is True]
+    fail = [(dc, v) for dc, v in results.items() if v is not True]
+    if len(ok) == len(_CFPROXY_TEST_DCS):
+        title = "CF-прокси: всё работает"
+        msg = f"\u2713 Все {len(_CFPROXY_TEST_DCS)} серверов доступны через {domain}."
+    elif not ok:
+        title = "CF-прокси: недоступен"
+        msg = f"\u2717 Ни один сервер не отвечает через {domain}.\n\nОшибки:\n"
+        msg += "\n".join(f"  kws{dc}: {v}" for dc, v in fail)
+    else:
+        title = "CF-прокси: частично работает"
+        msg = (
+            f"Домен: {domain}\n\n"
+            f"\u2713 Работают: {', '.join(f'kws{dc}' for dc in ok)}\n\n"
+            f"\u2717 Недоступны:\n"
+            + "\n".join(f"  kws{dc}: {v}" for dc, v in fail)
+        )
+    root = _tk.Tk()
+    root.withdraw()
+    try:
+        root.attributes("-topmost", True)
+    except Exception:
+        pass
+    _mb.showinfo(title, msg, parent=root)
+    root.destroy()
+
+
+def _cfproxy_show_auto_test_results(ok_domain, results: dict) -> None:
+    import tkinter as _tk
+    from tkinter import messagebox as _mb
+
+    if ok_domain is not None:
+        title = "CF-прокси: доступен"
+        ok = [dc for dc, v in results.items() if v is True]
+        msg = f"\u2713 CF-прокси работает. {len(ok)} из {len(_CFPROXY_TEST_DCS)} серверов доступны."
+    else:
+        title = "CF-прокси: недоступен"
+        msg = "\u2717 Ни один из автоматических CF-доменов не отвечает.\n"
+        msg += "Возможно, блокировка или проблемы с сетью."
+    root = _tk.Tk()
+    root.withdraw()
+    try:
+        root.attributes("-topmost", True)
+    except Exception:
+        pass
+    _mb.showinfo(title, msg, parent=root)
+    root.destroy()
+
+_INNER_W = 396
+
+_APPEARANCE_OPTIONS = ["Авто", "Светлая", "Тёмная"]
+_APPEARANCE_FROM_CFG = {"auto": "Авто", "light": "Светлая", "dark": "Тёмная"}
+_APPEARANCE_TO_CFG = {"Авто": "auto", "Светлая": "light", "Тёмная": "dark"}
+_APPEARANCE_TO_CTK = {"auto": "system", "light": "Light", "dark": "Dark"}
+
+
+def _entry(ctk, parent, theme, *, var=None, width=0, height=36, radius=10, **kw):
+    opts = dict(
+        font=(theme.ui_font_family, 13), corner_radius=radius,
+        fg_color=theme.bg, border_color=theme.field_border,
+        border_width=1, text_color=theme.text_primary,
+    )
+    if var is not None:
+        opts["textvariable"] = var
+    if width:
+        opts["width"] = width
+    opts["height"] = height
+    opts.update(kw)
+    return ctk.CTkEntry(parent, **opts)
+
+
+def _checkbox(ctk, parent, theme, text, variable):
+    return ctk.CTkCheckBox(
+        parent, text=text, variable=variable,
+        font=(theme.ui_font_family, 13), text_color=theme.text_primary,
+        fg_color=theme.tg_blue, hover_color=theme.tg_blue_hover,
+        corner_radius=6, border_width=2, border_color=theme.field_border,
+    )
+
+
+def _label(ctk, parent, theme, text, *, size=12, bold=False, secondary=True, **kw):
+    weight = "bold" if bold else "normal"
+    return ctk.CTkLabel(
+        parent, text=text,
+        font=(theme.ui_font_family, size, weight),
+        text_color=theme.text_secondary if secondary else theme.text_primary,
+        anchor="w", **kw,
+    )
+
+
+def _labeled_entry(ctk, parent, theme, label_text, value, *, tip="", width=0, pack_fill=False):
+    col = ctk.CTkFrame(parent, fg_color="transparent")
+    lbl = _label(ctk, col, theme, label_text)
+    lbl.pack(anchor="w", pady=(0, 2))
+    var = ctk.StringVar(value=str(value))
+    ent = _entry(ctk, col, theme, var=var, width=width)
+    if pack_fill:
+        ent.pack(fill="x")
+    else:
+        ent.pack(anchor="w")
+    if tip:
+        attach_tooltip_to_widgets([lbl, ent, col], tip)
+    return col, var
 
 
 def tray_settings_scroll_and_footer(
@@ -68,10 +244,6 @@ def tray_settings_scroll_and_footer(
     content_parent: Any,
     theme: CtkTheme,
 ) -> Tuple[Any, Any]:
-    """
-    Нижняя панель под кнопки и прокручиваемая область для формы (форма не обрезает кнопки).
-    Возвращает (scroll_frame, footer_frame).
-    """
     footer = ctk.CTkFrame(content_parent, fg_color=theme.bg)
     footer.pack(side="bottom", fill="x")
     scroll = ctk.CTkScrollableFrame(
@@ -93,22 +265,12 @@ def _config_section(
     *,
     bottom_spacer: int = 6,
 ) -> Any:
-    """Заголовок секции и карточка с рамкой для группировки полей."""
     wrap = ctk.CTkFrame(parent, fg_color="transparent")
     wrap.pack(fill="x", pady=(0, bottom_spacer))
-    ctk.CTkLabel(
+    _label(ctk, wrap, theme, title, secondary=False, bold=True).pack(anchor="w", pady=(0, 2))
-        wrap,
-        text=title,
-        font=(theme.ui_font_family, 12, "bold"),
-        text_color=theme.text_primary,
-        anchor="w",
-    ).pack(anchor="w", pady=(0, 2))
     card = ctk.CTkFrame(
-        wrap,
+        wrap, fg_color=theme.field_bg, corner_radius=10,
-        fg_color=theme.field_bg,
+        border_width=1, border_color=theme.field_border,
-        corner_radius=10,
-        border_width=1,
-        border_color=theme.field_border,
     )
     card.pack(fill="x")
     inner = ctk.CTkFrame(card, fg_color="transparent")
@@ -120,12 +282,17 @@ def _config_section(
 class TrayConfigFormWidgets:
     host_var: Any
     port_var: Any
+    secret_var: Any
     dc_textbox: Any
     verbose_var: Any
     adv_entries: List[Any]
     adv_keys: Tuple[str, ...]
     autostart_var: Optional[Any]
     check_updates_var: Optional[Any]
+    cfproxy_var: Optional[Any] = None
+    cfproxy_priority_var: Optional[Any] = None
+    cfproxy_user_domain_var: Optional[Any] = None
+    appearance_var: Optional[Any] = None
 
 
 def install_tray_config_form(
@@ -138,122 +305,189 @@ def install_tray_config_form(
     show_autostart: bool = False,
     autostart_value: bool = False,
 ) -> TrayConfigFormWidgets:
-    """Поля настроек прокси внутри уже созданного `frame`."""
     header = ctk.CTkFrame(frame, fg_color="transparent")
     header.pack(fill="x", pady=(0, 2))
     ctk.CTkLabel(
-        header,
+        header, text="Настройки прокси",
-        text="Настройки прокси",
         font=(theme.ui_font_family, 17, "bold"),
-        text_color=theme.text_primary,
+        text_color=theme.text_primary, anchor="w",
-        anchor="w",
     ).pack(side="left")
     ctk.CTkLabel(
+        header, text=f"v{__version__}",
+        font=(theme.ui_font_family, 12),
+        text_color=theme.text_secondary, anchor="e",
+    ).pack(side="right", padx=(4, 0))
+    appearance_var = ctk.StringVar(
+        value=_APPEARANCE_FROM_CFG.get(cfg.get("appearance", "auto"), "Авто")
+    )
+
+    def _on_appearance_change(choice: str) -> None:
+        cfg_val = _APPEARANCE_TO_CFG.get(choice, "auto")
+        ctk.set_appearance_mode(_APPEARANCE_TO_CTK[cfg_val])
+
+    ctk.CTkComboBox(
         header,
-        text=f"v{__version__}",
+        values=_APPEARANCE_OPTIONS,
+        variable=appearance_var,
+        width=102,
+        height=28,
         font=(theme.ui_font_family, 12),
         text_color=theme.text_secondary,
-        anchor="e",
+        fg_color=theme.field_bg,
+        border_color=theme.field_border,
+        button_color=theme.field_border,
+        button_hover_color=theme.text_secondary,
+        dropdown_fg_color=theme.field_bg,
+        dropdown_text_color=theme.text_primary,
+        dropdown_hover_color=theme.field_border,
+        corner_radius=8,
+        state="readonly",
+        command=_on_appearance_change,
     ).pack(side="right")
 
-    inner_w = _CONFIG_FORM_INNER_WIDTH
+    conn = _config_section(ctk, frame, theme, "Подключение MTProto")
-
-    conn = _config_section(ctk, frame, theme, "Подключение SOCKS5")
 
     host_row = ctk.CTkFrame(conn, fg_color="transparent")
     host_row.pack(fill="x")
 
-    host_col = ctk.CTkFrame(host_row, fg_color="transparent")
+    host_col, host_var = _labeled_entry(
+        ctk, host_row, theme, "IP-адрес",
+        cfg.get("host", default_config["host"]),
+        tip=_TIP_HOST, width=160, pack_fill=True,
+    )
     host_col.pack(side="left", fill="x", expand=True, padx=(0, 10))
-    host_lbl = ctk.CTkLabel(
-        host_col,
-        text="IP-адрес",
-        font=(theme.ui_font_family, 12),
-        text_color=theme.text_secondary,
-        anchor="w",
-    )
-    host_lbl.pack(anchor="w", pady=(0, 2))
-    host_var = ctk.StringVar(value=cfg.get("host", default_config["host"]))
-    host_entry = ctk.CTkEntry(
-        host_col,
-        textvariable=host_var,
-        width=160,
-        height=36,
-        font=(theme.ui_font_family, 13),
-        corner_radius=10,
-        fg_color=theme.bg,
-        border_color=theme.field_border,
-        border_width=1,
-        text_color=theme.text_primary,
-    )
-    host_entry.pack(fill="x", pady=(0, 0))
-    attach_tooltip_to_widgets([host_lbl, host_entry, host_col], _TIP_HOST)
 
-    port_col = ctk.CTkFrame(host_row, fg_color="transparent")
+    port_col, port_var = _labeled_entry(
+        ctk, host_row, theme, "Порт",
+        cfg.get("port", default_config["port"]),
+        tip=_TIP_PORT, width=100,
+    )
     port_col.pack(side="left")
-    port_lbl = ctk.CTkLabel(
+
-        port_col,
+    secret_row = ctk.CTkFrame(conn, fg_color="transparent")
-        text="Порт",
+    secret_row.pack(fill="x")
-        font=(theme.ui_font_family, 12),
+
-        text_color=theme.text_secondary,
+    secret_col, secret_var = _labeled_entry(
-        anchor="w",
+        ctk, secret_row, theme, "Secret",
+        cfg.get("secret", default_config["secret"]),
+        tip=_TIP_SECRET, width=160, pack_fill=True,
     )
-    port_lbl.pack(anchor="w", pady=(0, 2))
+    secret_col.pack(side="left", fill="x", expand=True, padx=(0, 10))
-    port_var = ctk.StringVar(value=str(cfg.get("port", default_config["port"])))
+
-    port_entry = ctk.CTkEntry(
+    regen_col = ctk.CTkFrame(secret_row, fg_color="transparent")
-        port_col,
+    regen_col.pack(side="left", anchor="s")
-        textvariable=port_var,
+    ctk.CTkLabel(regen_col, text="", font=(theme.ui_font_family, 12)).pack(pady=(0, 2))
-        width=100,
+    ctk.CTkButton(
-        height=36,
+        regen_col, text="↺", width=36, height=36,
-        font=(theme.ui_font_family, 13),
+        font=(theme.ui_font_family, 18), corner_radius=10,
-        corner_radius=10,
+        fg_color=theme.tg_blue, hover_color=theme.tg_blue_hover,
-        fg_color=theme.bg,
+        text_color="#ffffff", border_width=1, border_color=theme.field_border,
-        border_color=theme.field_border,
+        command=lambda: secret_var.set(os.urandom(16).hex()),
-        border_width=1,
+    ).pack()
-        text_color=theme.text_primary,
-    )
-    port_entry.pack(anchor="w")
-    attach_tooltip_to_widgets([port_lbl, port_entry, port_col], _TIP_PORT)
 
     dc_inner = _config_section(ctk, frame, theme, "Датацентры Telegram (DC → IP)")
-    dc_lbl = ctk.CTkLabel(
+    dc_lbl = _label(ctk, dc_inner, theme, "По одному правилу на строку, формат: номер:IP", size=11)
-        dc_inner,
-        text="По одному правилу на строку, формат: номер:IP",
-        font=(theme.ui_font_family, 11),
-        text_color=theme.text_secondary,
-        anchor="w",
-    )
     dc_lbl.pack(anchor="w", pady=(0, 4))
     dc_textbox = ctk.CTkTextbox(
-        dc_inner,
+        dc_inner, width=_INNER_W, height=88,
-        width=inner_w,
+        font=(theme.mono_font_family, 12), corner_radius=10,
-        height=88,
+        fg_color=theme.bg, border_color=theme.field_border,
-        font=(theme.mono_font_family, 12),
+        border_width=1, text_color=theme.text_primary,
-        corner_radius=10,
-        fg_color=theme.bg,
-        border_color=theme.field_border,
-        border_width=1,
-        text_color=theme.text_primary,
     )
     dc_textbox.pack(fill="x")
     dc_textbox.insert("1.0", "\n".join(cfg.get("dc_ip", default_config["dc_ip"])))
     attach_tooltip_to_widgets([dc_lbl, dc_textbox], _TIP_DC)
 
+    cf_inner = _config_section(ctk, frame, theme, "Cloudflare Proxy")
+
+    cf_row = ctk.CTkFrame(cf_inner, fg_color="transparent")
+    cf_row.pack(fill="x", pady=(0, 4))
+
+    cfproxy_var = ctk.BooleanVar(
+        value=cfg.get("cfproxy", default_config.get("cfproxy", True))
+    )
+    cf_cb = _checkbox(ctk, cf_row, theme, "Включить CF-прокси", cfproxy_var)
+    cf_cb.pack(side="left", padx=(0, 16))
+    attach_ctk_tooltip(cf_cb, _TIP_CFPROXY)
+
+    cfproxy_priority_var = ctk.BooleanVar(
+        value=cfg.get("cfproxy_priority", default_config.get("cfproxy_priority", True))
+    )
+    cf_prio_cb = _checkbox(ctk, cf_row, theme, "Приоритет", cfproxy_priority_var)
+    cf_prio_cb.pack(side="left")
+    attach_ctk_tooltip(cf_prio_cb, _TIP_CFPROXY_PRIORITY)
+
+    _cf_test_btn = [None]
+
+    def _on_cf_test():
+        user_domain = cfproxy_user_domain_var.get().strip() if cf_custom_cb_var.get() else ""
+        btn = _cf_test_btn[0]
+        if btn:
+            btn.configure(text="...", state="disabled")
+        import threading as _threading
+        if user_domain:
+            def _worker():
+                res = _run_cfproxy_connectivity_test(user_domain)
+                if btn:
+                    btn.after(0, lambda: btn.configure(text="Тест", state="normal"))
+                    btn.after(0, lambda: _cfproxy_show_test_results(user_domain, res))
+            _threading.Thread(target=_worker, daemon=True).start()
+        else:
+            def _worker_auto():
+                ok_domain, res = _run_cfproxy_auto_test(CFPROXY_DEFAULT_DOMAINS)
+                if btn:
+                    btn.after(0, lambda: btn.configure(text="Тест", state="normal"))
+                    btn.after(0, lambda: _cfproxy_show_auto_test_results(ok_domain, res))
+            _threading.Thread(target=_worker_auto, daemon=True).start()
+
+    _cf_test_widget = ctk.CTkButton(
+        cf_row, text="Тест", width=56, height=28,
+        font=(theme.ui_font_family, 13), corner_radius=8,
+        fg_color=theme.tg_blue, hover_color=theme.tg_blue_hover,
+        text_color="#ffffff", border_width=1, border_color=theme.field_border,
+        command=_on_cf_test,
+    )
+    _cf_test_widget.pack(side="right")
+    _cf_test_btn[0] = _cf_test_widget
+
+    cf_custom_row = ctk.CTkFrame(cf_inner, fg_color="transparent")
+    cf_custom_row.pack(fill="x")
+
+    saved_user_domain = cfg.get("cfproxy_user_domain", default_config.get("cfproxy_user_domain", ""))
+    cf_custom_cb_var = ctk.BooleanVar(value=bool(saved_user_domain))
+    cf_custom_cb = _checkbox(ctk, cf_custom_row, theme, "Свой домен", cf_custom_cb_var)
+    cf_custom_cb.pack(side="left", padx=(0, 10))
+    attach_ctk_tooltip(cf_custom_cb, _TIP_CFPROXY_USER_DOMAIN_CB)
+
+    ctk.CTkButton(
+        cf_custom_row, text="?", width=28, height=32,
+        font=(theme.ui_font_family, 14), corner_radius=8,
+        fg_color=theme.tg_blue, hover_color=theme.tg_blue_hover,
+        text_color="#ffffff", border_width=1, border_color=theme.field_border,
+        command=lambda: webbrowser.open(_CFPROXY_HELP_URL),
+    ).pack(side="right")
+
+    cfproxy_user_domain_var = ctk.StringVar(value=saved_user_domain)
+    cf_domain_entry = _entry(
+        ctk, cf_custom_row, theme, var=cfproxy_user_domain_var,
+        height=32, radius=8,
+    )
+    cf_domain_entry.pack(side="left", fill="x", expand=True, padx=(0, 6))
+    attach_ctk_tooltip(cf_domain_entry, _TIP_CFPROXY_DOMAIN)
+
+    def _sync_domain_entry(*_):
+        state = "normal" if cf_custom_cb_var.get() else "disabled"
+        cf_domain_entry.configure(state=state)
+        if not cf_custom_cb_var.get():
+            cfproxy_user_domain_var.set("")
+
+    cf_custom_cb_var.trace_add("write", _sync_domain_entry)
+    _sync_domain_entry()
+
     log_inner = _config_section(ctk, frame, theme, "Логи и производительность")
 
     verbose_var = ctk.BooleanVar(value=cfg.get("verbose", False))
-    verbose_cb = ctk.CTkCheckBox(
+    verbose_cb = _checkbox(ctk, log_inner, theme, "Подробное логирование (verbose)", verbose_var)
-        log_inner,
-        text="Подробное логирование (verbose)",
-        variable=verbose_var,
-        font=(theme.ui_font_family, 13),
-        text_color=theme.text_primary,
-        fg_color=theme.tg_blue,
-        hover_color=theme.tg_blue_hover,
-        corner_radius=6,
-        border_width=2,
-        border_color=theme.field_border,
-    )
     verbose_cb.pack(anchor="w", pady=(0, 6))
     attach_ctk_tooltip(verbose_cb, _TIP_VERBOSE)
 
@@ -265,33 +499,17 @@ def install_tray_config_form(
         ("Пул WebSocket-сессий (по умолчанию 4)", "pool_size", _TIP_POOL),
         ("Макс. размер лога, МБ (по умолчанию 5)", "log_max_mb", _TIP_LOG_MB),
     ]
-    for lbl, key, tip in adv_rows:
+    for label_text, key, tip in adv_rows:
-        col_frame = ctk.CTkFrame(adv_frame, fg_color="transparent")
+        col = ctk.CTkFrame(adv_frame, fg_color="transparent")
-        col_frame.pack(fill="x", pady=(0, 0 if key == "log_max_mb" else 5))
+        col.pack(fill="x", pady=(0, 0 if key == "log_max_mb" else 5))
-        adv_l = ctk.CTkLabel(
+        adv_l = _label(ctk, col, theme, label_text, size=11)
-            col_frame,
-            text=lbl,
-            font=(theme.ui_font_family, 11),
-            text_color=theme.text_secondary,
-            anchor="w",
-        )
         adv_l.pack(anchor="w", pady=(0, 2))
-        adv_e = ctk.CTkEntry(
+        adv_e = _entry(
-            col_frame,
+            ctk, col, theme, width=_INNER_W, height=32, radius=8,
-            width=inner_w,
+            textvariable=ctk.StringVar(value=str(cfg.get(key, default_config[key]))),
-            height=32,
-            font=(theme.ui_font_family, 13),
-            corner_radius=8,
-            fg_color=theme.bg,
-            border_color=theme.field_border,
-            border_width=1,
-            text_color=theme.text_primary,
-            textvariable=ctk.StringVar(
-                value=str(cfg.get(key, default_config[key]))
-            ),
         )
         adv_e.pack(fill="x")
-        attach_tooltip_to_widgets([adv_l, adv_e, col_frame], tip)
+        attach_tooltip_to_widgets([adv_l, adv_e, col], tip)
 
     adv_entries = list(adv_frame.winfo_children())
     adv_keys = ("buf_kb", "pool_size", "log_max_mb")
@@ -299,22 +517,9 @@ def install_tray_config_form(
     upd_inner = _config_section(ctk, frame, theme, "Обновления")
     st = get_status()
     check_updates_var = ctk.BooleanVar(
-        value=bool(
+        value=bool(cfg.get("check_updates", default_config.get("check_updates", True)))
-            cfg.get("check_updates", default_config.get("check_updates", True))
-        )
-    )
-    upd_cb = ctk.CTkCheckBox(
-        upd_inner,
-        text="Проверять обновления при запуске",
-        variable=check_updates_var,
-        font=(theme.ui_font_family, 13),
-        text_color=theme.text_primary,
-        fg_color=theme.tg_blue,
-        hover_color=theme.tg_blue_hover,
-        corner_radius=6,
-        border_width=2,
-        border_color=theme.field_border,
     )
+    upd_cb = _checkbox(ctk, upd_inner, theme, "Проверять обновления при запуске", check_updates_var)
     upd_cb.pack(anchor="w", pady=(0, 6))
     attach_ctk_tooltip(upd_cb, _TIP_CHECK_UPDATES)
 
@@ -335,72 +540,42 @@ def install_tray_config_form(
     else:
         upd_status = "Установлена последняя известная версия с GitHub."
 
-    ctk.CTkLabel(
+    _label(ctk, upd_inner, theme, upd_status, size=11,
-        upd_inner,
+           justify="left", wraplength=_INNER_W).pack(anchor="w", pady=(0, 8))
-        text=upd_status,
-        font=(theme.ui_font_family, 11),
-        text_color=theme.text_secondary,
-        anchor="w",
-        justify="left",
-        wraplength=inner_w,
-    ).pack(anchor="w", pady=(0, 8))
 
     rel_url = (st.get("html_url") or "").strip() or RELEASES_PAGE_URL
-    open_rel_btn = ctk.CTkButton(
+    ctk.CTkButton(
-        upd_inner,
+        upd_inner, text="Открыть страницу релиза", height=32,
-        text="Открыть страницу релиза",
+        font=(theme.ui_font_family, 13), corner_radius=8,
-        height=32,
+        fg_color=theme.field_bg, hover_color=theme.field_border,
-        font=(theme.ui_font_family, 13),
+        text_color=theme.text_primary, border_width=1,
-        corner_radius=8,
-        fg_color=theme.field_bg,
-        hover_color=theme.field_border,
-        text_color=theme.text_primary,
-        border_width=1,
         border_color=theme.field_border,
         command=lambda u=rel_url: webbrowser.open(u),
-    )
+    ).pack(anchor="w")
-    open_rel_btn.pack(anchor="w")
 
     autostart_var = None
     if show_autostart:
-        sys_inner = _config_section(
+        sys_inner = _config_section(ctk, frame, theme, "Запуск Windows", bottom_spacer=4)
-            ctk, frame, theme, "Запуск Windows", bottom_spacer=4
-        )
         autostart_var = ctk.BooleanVar(value=autostart_value)
-        as_cb = ctk.CTkCheckBox(
+        as_cb = _checkbox(ctk, sys_inner, theme, "Автозапуск при включении компьютера", autostart_var)
-            sys_inner,
-            text="Автозапуск при включении компьютера",
-            variable=autostart_var,
-            font=(theme.ui_font_family, 13),
-            text_color=theme.text_primary,
-            fg_color=theme.tg_blue,
-            hover_color=theme.tg_blue_hover,
-            corner_radius=6,
-            border_width=2,
-            border_color=theme.field_border,
-        )
         as_cb.pack(anchor="w", pady=(0, 4))
-        as_hint = ctk.CTkLabel(
+        as_hint = _label(
-            sys_inner,
+            ctk, sys_inner, theme,
-            text="Если переместить программу в другую папку, запись автозапуска может сброситься.",
+            "Если переместить программу в другую папку, запись автозапуска может сброситься.",
-            font=(theme.ui_font_family, 11),
+            size=11, justify="left", wraplength=_INNER_W,
-            text_color=theme.text_secondary,
-            anchor="w",
-            justify="left",
-            wraplength=inner_w,
         )
         as_hint.pack(anchor="w")
         attach_tooltip_to_widgets([as_cb, as_hint], _TIP_AUTOSTART)
 
     return TrayConfigFormWidgets(
-        host_var=host_var,
+        host_var=host_var, port_var=port_var, secret_var=secret_var,
-        port_var=port_var,
+        dc_textbox=dc_textbox, verbose_var=verbose_var,
-        dc_textbox=dc_textbox,
+        adv_entries=adv_entries, adv_keys=adv_keys,
-        verbose_var=verbose_var,
+        autostart_var=autostart_var, check_updates_var=check_updates_var,
-        adv_entries=adv_entries,
+        cfproxy_var=cfproxy_var,
-        adv_keys=adv_keys,
+        cfproxy_priority_var=cfproxy_priority_var,
-        autostart_var=autostart_var,
+        cfproxy_user_domain_var=cfproxy_user_domain_var,
-        check_updates_var=check_updates_var,
+        appearance_var=appearance_var,
     )
 
 
@@ -409,7 +584,6 @@ def merge_adv_from_form(
     base: Dict[str, Any],
     default_config: dict,
 ) -> None:
-    """Дополняет base значениями buf_kb / pool_size / log_max_mb (in-place)."""
     for i, key in enumerate(widgets.adv_keys):
         col_frame = widgets.adv_entries[i]
         entry = col_frame.winfo_children()[1]
@@ -428,9 +602,6 @@ def validate_config_form(
     *,
     include_autostart: bool,
 ) -> Union[dict, str]:
-    """
-    Возвращает словарь полей конфига или строку ошибки для показа пользователю.
-    """
     import socket as _sock
 
     host_val = widgets.host_var.get().strip()
@@ -447,18 +618,27 @@ def validate_config_form(
         return "Порт должен быть числом 1-65535"
 
     lines = [
-        l.strip()
+        line.strip()
-        for l in widgets.dc_textbox.get("1.0", "end").strip().splitlines()
+        for line in widgets.dc_textbox.get("1.0", "end").strip().splitlines()
-        if l.strip()
+        if line.strip()
     ]
     try:
-        tg_ws_proxy.parse_dc_ip_list(lines)
+        parse_dc_ip_list(lines)
     except ValueError as e:
         return str(e)
 
+    secret_val = widgets.secret_var.get().strip()
+    if len(secret_val) != 32:
+        return "Secret должен содержать ровно 32 hex-символа (16 байт)."
+    try:
+        bytes.fromhex(secret_val)
+    except ValueError:
+        return "Secret должен состоять только из hex-символов (0-9, a-f)."
+
     new_cfg: Dict[str, Any] = {
         "host": host_val,
         "port": port_val,
+        "secret": secret_val,
         "dc_ip": lines,
         "verbose": widgets.verbose_var.get(),
     }
@@ -472,6 +652,14 @@ def validate_config_form(
     merge_adv_from_form(widgets, new_cfg, default_config)
     if widgets.check_updates_var is not None:
         new_cfg["check_updates"] = bool(widgets.check_updates_var.get())
+    if widgets.cfproxy_var is not None:
+        new_cfg["cfproxy"] = bool(widgets.cfproxy_var.get())
+    if widgets.cfproxy_priority_var is not None:
+        new_cfg["cfproxy_priority"] = bool(widgets.cfproxy_priority_var.get())
+    if widgets.cfproxy_user_domain_var is not None:
+        new_cfg["cfproxy_user_domain"] = widgets.cfproxy_user_domain_var.get().strip()
+    if widgets.appearance_var is not None:
+        new_cfg["appearance"] = _APPEARANCE_TO_CFG.get(widgets.appearance_var.get(), "auto")
     return new_cfg
 
 
@@ -517,12 +705,11 @@ def populate_first_run_window(
     *,
     host: str,
     port: int,
+    secret: str,
     on_done: Callable[[bool], None],
 ) -> None:
-    """
+    link_host = get_link_host(host)
-    Содержимое окна первого запуска. on_done(open_in_telegram) — по «Начать» и по закрытию окна.
+    tg_url = f"tg://proxy?server={link_host}&port={port}&secret=dd{secret}"
-    """
-    tg_url = f"tg://socks?server={host}&port={port}"
     fpx, fpy = FIRST_RUN_FRAME_PAD
     frame = main_content_frame(ctk, root, theme, padx=fpx, pady=fpy)
 
@@ -541,18 +728,35 @@ def populate_first_run_window(
         ("Как подключить Telegram Desktop:", True),
         ("  Автоматически:", True),
         ("  ПКМ по иконке в трее → «Открыть в Telegram»", False),
-        (f"  Или ссылка: {tg_url}", False),
+        (f"  Или скопировать ссылку, отправить её себе в TG и нажать по ней: {tg_url}", False),
         ("\n  Вручную:", True),
         ("  Настройки → Продвинутые → Тип подключения → Прокси", False),
-        (f"  SOCKS5 → {host} : {port} (без логина/пароля)", False),
+        (f"  MTProto → {link_host} : {port}", False),
+        (f"  Secret: dd{secret}", False),
     ]
 
+    textbox = ctk.CTkTextbox(
+        frame,
+        font=(theme.ui_font_family, 13),
+        fg_color=theme.bg,
+        border_width=0,
+        text_color=theme.text_primary,
+        activate_scrollbars=False,
+        wrap="word",
+        height=275,
+    )
+    textbox._textbox.tag_configure("bold", font=(theme.ui_font_family, 13, "bold"))
+    textbox._textbox.configure(spacing1=1, spacing3=1)
     for text, bold in sections:
-        weight = "bold" if bold else "normal"
+        if text.startswith("\n"):
-        ctk.CTkLabel(frame, text=text,
+            textbox.insert("end", "\n")
-                     font=(theme.ui_font_family, 13, weight),
+            text = text[1:]
-                     text_color=theme.text_primary,
+        if bold:
-                     anchor="w", justify="left").pack(anchor="w", pady=1)
+            textbox.insert("end", text + "\n", "bold")
+        else:
+            textbox.insert("end", text + "\n")
+    textbox.configure(state="disabled")
+    textbox.pack(anchor="w", fill="x")
 
     ctk.CTkFrame(frame, fg_color="transparent", height=16).pack()
 
@@ -560,12 +764,8 @@ def populate_first_run_window(
                  corner_radius=0).pack(fill="x", pady=(0, 12))
 
     auto_var = ctk.BooleanVar(value=True)
-    ctk.CTkCheckBox(frame, text="Открыть прокси в Telegram сейчас",
+    _checkbox(ctk, frame, theme, "Открыть прокси в Telegram сейчас",
-                    variable=auto_var, font=(theme.ui_font_family, 13),
+              auto_var).pack(anchor="w", pady=(0, 16))
-                    text_color=theme.text_primary,
-                    fg_color=theme.tg_blue, hover_color=theme.tg_blue_hover,
-                    corner_radius=6, border_width=2,
-                    border_color=theme.field_border).pack(anchor="w", pady=(0, 16))
 
     def on_ok():
         on_done(auto_var.get())

utils/default_config.py

@@ -5,10 +5,11 @@
 from __future__ import annotations
 
 import sys
+import os
 from typing import Any, Dict
 
 _TRAY_DEFAULTS_COMMON: Dict[str, Any] = {
-    "port": 1080,
+    "port": 1443,
     "host": "127.0.0.1",
     "dc_ip": ["2:149.154.167.220", "4:149.154.167.220"],
     "verbose": False,
@@ -16,12 +17,17 @@ _TRAY_DEFAULTS_COMMON: Dict[str, Any] = {
     "log_max_mb": 5,
     "buf_kb": 256,
     "pool_size": 4,
+    "cfproxy": True,
+    "cfproxy_priority": True,
+    "cfproxy_user_domain": "",
 }
 
 
 def default_tray_config() -> Dict[str, Any]:
-    """Новая копия конфига по умолчанию для текущей ОС."""
     cfg = dict(_TRAY_DEFAULTS_COMMON)
+    cfg["secret"] = os.urandom(16).hex()
+
     if sys.platform == "win32":
         cfg["autostart"] = False
+
     return cfg

utils/tray_common.py

@@ -0,0 +1,468 @@
+from __future__ import annotations
+
+import asyncio
+import json
+import logging
+import logging.handlers
+import os
+import socket as _socket
+import sys
+import threading
+import time
+from pathlib import Path
+from typing import Any, Callable, Dict, Optional, Tuple
+
+import psutil
+
+from proxy import __version__, get_link_host, parse_dc_ip_list, proxy_config
+from proxy.tg_ws_proxy import _run
+from utils.default_config import default_tray_config
+
+log = logging.getLogger("tg-ws-tray")
+
+APP_NAME = "TgWsProxy"
+
+
+def _app_dir() -> Path:
+    if sys.platform == "win32":
+        return Path(os.environ.get("APPDATA", Path.home())) / APP_NAME
+    if sys.platform == "darwin":
+        return Path.home() / "Library" / "Application Support" / APP_NAME
+    return Path(os.environ.get("XDG_CONFIG_HOME", Path.home() / ".config")) / APP_NAME
+
+
+APP_DIR = _app_dir()
+CONFIG_FILE = APP_DIR / "config.json"
+LOG_FILE = APP_DIR / "proxy.log"
+FIRST_RUN_MARKER = APP_DIR / ".first_run_done_mtproto"
+IPV6_WARN_MARKER = APP_DIR / ".ipv6_warned"
+
+DEFAULT_CONFIG: Dict[str, Any] = default_tray_config()
+
+IS_FROZEN = bool(getattr(sys, "frozen", False))
+
+
+def ensure_dirs() -> None:
+    APP_DIR.mkdir(parents=True, exist_ok=True)
+
+
+# single-instance lock
+
+_lock_file_path: Optional[Path] = None
+
+
+def _same_process(meta: dict, proc: psutil.Process, script_hint: str) -> bool:
+    try:
+        lock_ct = float(meta.get("create_time", 0.0))
+        if lock_ct > 0 and abs(lock_ct - proc.create_time()) > 1.0:
+            return False
+    except Exception:
+        return False
+    if IS_FROZEN:
+        return APP_NAME.lower() in proc.name().lower()
+    return False
+
+
+def acquire_lock(script_hint: str = "") -> bool:
+    global _lock_file_path
+    ensure_dirs()
+    for f in list(APP_DIR.glob("*.lock")):
+        try:
+            pid = int(f.stem)
+        except Exception:
+            try:
+                f.unlink(missing_ok=True)
+            except OSError:
+                pass
+            continue
+        meta: dict = {}
+        try:
+            raw = f.read_text(encoding="utf-8").strip()
+            if raw:
+                meta = json.loads(raw)
+        except Exception:
+            pass
+        is_running = False
+        try:
+            is_running = _same_process(meta, psutil.Process(pid), script_hint)
+        except Exception:
+            pass
+        if is_running:
+            return False
+        try:
+            f.unlink(missing_ok=True)
+        except OSError:
+            pass
+
+    lock_file = APP_DIR / f"{os.getpid()}.lock"
+    try:
+        proc = psutil.Process(os.getpid())
+        lock_file.write_text(
+            json.dumps({"create_time": proc.create_time()}, ensure_ascii=False),
+            encoding="utf-8",
+        )
+    except Exception:
+        try:
+            lock_file.touch()
+        except Exception:
+            pass
+    _lock_file_path = lock_file
+    return True
+
+
+def release_lock() -> None:
+    global _lock_file_path
+    if _lock_file_path:
+        try:
+            _lock_file_path.unlink(missing_ok=True)
+        except Exception:
+            pass
+        _lock_file_path = None
+
+
+# config
+
+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) -> None:
+    ensure_dirs()
+    with open(CONFIG_FILE, "w", encoding="utf-8") as f:
+        json.dump(cfg, f, indent=2, ensure_ascii=False)
+
+
+# logging
+
+_LOG_FMT_FILE = "%(asctime)s  %(levelname)-5s  %(name)s  %(message)s"
+_LOG_FMT_CONSOLE = "%(asctime)s  %(levelname)-5s  %(message)s"
+
+
+def setup_logging(verbose: bool = False, log_max_mb: float = 5) -> None:
+    ensure_dirs()
+    level = logging.DEBUG if verbose else logging.INFO
+    root = logging.getLogger()
+    root.setLevel(level)
+
+    fh = logging.handlers.RotatingFileHandler(
+        str(LOG_FILE),
+        maxBytes=max(32 * 1024, int(log_max_mb * 1024 * 1024)),
+        backupCount=0,
+        encoding="utf-8",
+    )
+    fh.setLevel(logging.DEBUG)
+    fh.setFormatter(logging.Formatter(_LOG_FMT_FILE, datefmt="%Y-%m-%d %H:%M:%S"))
+    root.addHandler(fh)
+
+    if not IS_FROZEN:
+        ch = logging.StreamHandler(sys.stdout)
+        ch.setLevel(level)
+        ch.setFormatter(logging.Formatter(_LOG_FMT_CONSOLE, datefmt="%H:%M:%S"))
+        root.addHandler(ch)
+
+
+# icon
+
+def make_icon_image(size: int = 64, *, color: Tuple[int, ...] = (0, 136, 204, 255)):
+    from PIL import Image, ImageDraw, ImageFont
+
+    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=color)
+
+    for path in _font_paths():
+        try:
+            font = ImageFont.truetype(path, size=int(size * 0.55))
+            break
+        except Exception:
+            continue
+    else:
+        font = ImageFont.load_default()
+
+    bbox = draw.textbbox((0, 0), "T", font=font)
+    tw, th = bbox[2] - bbox[0], bbox[3] - bbox[1]
+    draw.text(
+        ((size - tw) // 2 - bbox[0], (size - th) // 2 - bbox[1]),
+        "T",
+        fill=(255, 255, 255, 255),
+        font=font,
+    )
+    return img
+
+
+def _font_paths():
+    if sys.platform == "win32":
+        return ["arial.ttf"]
+    if sys.platform == "darwin":
+        return ["/System/Library/Fonts/Helvetica.ttc"]
+    return [
+        "/usr/share/fonts/truetype/dejavu/DejaVuSans-Bold.ttf",
+        "/usr/share/fonts/TTF/DejaVuSans-Bold.ttf",
+    ]
+
+
+def load_icon():
+    from PIL import Image
+
+    icon_path = Path(__file__).parents[1] / "icon.ico"
+    if icon_path.exists():
+        try:
+            return Image.open(str(icon_path))
+        except Exception:
+            pass
+    return make_icon_image(64)
+
+
+# proxy lifecycle
+
+_proxy_thread: Optional[threading.Thread] = None
+_async_stop: Optional[Tuple[asyncio.AbstractEventLoop, asyncio.Event]] = None
+
+
+def _run_proxy_thread(on_port_busy: Callable[[str], None]) -> None:
+    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(_run(stop_event=stop_ev))
+    except Exception as exc:
+        log.error("Proxy thread crashed: %s", exc)
+        if "Address already in use" in str(exc) or "10048" in str(exc):
+            on_port_busy(
+                "Не удалось запустить прокси:\n"
+                "Порт уже используется другим приложением.\n\n"
+                "Закройте приложение, использующее этот порт, "
+                "или измените порт в настройках прокси и перезапустите."
+            )
+    finally:
+        loop.close()
+        _async_stop = None
+
+
+def apply_proxy_config(cfg: dict) -> bool:
+    dc_ip_list = cfg.get("dc_ip", DEFAULT_CONFIG["dc_ip"])
+    try:
+        dc_redirects = parse_dc_ip_list(dc_ip_list)
+    except ValueError as e:
+        log.error("Bad config dc_ip: %s", e)
+        return False
+
+    pc = proxy_config
+    pc.port = cfg.get("port", DEFAULT_CONFIG["port"])
+    pc.host = cfg.get("host", DEFAULT_CONFIG["host"])
+    pc.secret = cfg.get("secret", DEFAULT_CONFIG["secret"])
+    pc.dc_redirects = dc_redirects
+    pc.buffer_size = max(4, cfg.get("buf_kb", DEFAULT_CONFIG["buf_kb"])) * 1024
+    pc.pool_size = max(0, cfg.get("pool_size", DEFAULT_CONFIG["pool_size"]))
+    pc.fallback_cfproxy = cfg.get("cfproxy", DEFAULT_CONFIG["cfproxy"])
+    pc.fallback_cfproxy_priority = cfg.get("cfproxy_priority", DEFAULT_CONFIG["cfproxy_priority"])
+    pc.cfproxy_user_domain = cfg.get("cfproxy_user_domain", DEFAULT_CONFIG["cfproxy_user_domain"])
+    return True
+
+
+def start_proxy(cfg: dict, on_error: Callable[[str], None]) -> None:
+    global _proxy_thread
+    if _proxy_thread and _proxy_thread.is_alive():
+        log.info("Proxy already running")
+        return
+
+    if not apply_proxy_config(cfg):
+        on_error("Ошибка конфигурации DC → IP.")
+        return
+
+    pc = proxy_config
+    log.info("Starting proxy on %s:%d ...", pc.host, pc.port)
+    _proxy_thread = threading.Thread(
+        target=_run_proxy_thread, args=(on_error,), daemon=True, name="proxy"
+    )
+    _proxy_thread.start()
+
+
+def stop_proxy() -> None:
+    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=5)
+    _proxy_thread = None
+    log.info("Proxy stopped")
+
+
+def restart_proxy(cfg: dict, on_error: Callable[[str], None]) -> None:
+    log.info("Restarting proxy...")
+    stop_proxy()
+    time.sleep(0.3)
+    start_proxy(cfg, on_error)
+
+
+def tg_proxy_url(cfg: dict) -> str:
+    host = cfg.get("host", DEFAULT_CONFIG["host"])
+    port = cfg.get("port", DEFAULT_CONFIG["port"])
+    secret = cfg.get("secret", DEFAULT_CONFIG["secret"])
+    link_host = get_link_host(host)
+    return f"tg://proxy?server={link_host}&port={port}&secret=dd{secret}"
+
+
+_IPV6_WARNING = (
+    "На вашем компьютере включена поддержка подключения по IPv6.\n\n"
+    "Telegram может пытаться подключаться через IPv6, "
+    "что не поддерживается и может привести к ошибкам.\n\n"
+    "Если прокси не работает или в логах присутствуют ошибки, "
+    "связанные с попытками подключения по IPv6 - "
+    "попробуйте отключить в настройках прокси Telegram попытку соединения "
+    "по IPv6. Если данная мера не помогает, попробуйте отключить IPv6 "
+    "в системе.\n\n"
+    "Это предупреждение будет показано только один раз."
+)
+
+
+def _has_ipv6() -> bool:
+    try:
+        for addr in _socket.getaddrinfo(_socket.gethostname(), None, _socket.AF_INET6):
+            ip = addr[4][0]
+            if ip and not ip.startswith("::1") and not ip.startswith("fe80::1"):
+                return True
+    except Exception:
+        pass
+    try:
+        s = _socket.socket(_socket.AF_INET6, _socket.SOCK_STREAM)
+        s.bind(("::1", 0))
+        s.close()
+        return True
+    except Exception:
+        return False
+
+
+def check_ipv6_warning(show_info: Callable[[str, str], None]) -> None:
+    ensure_dirs()
+    if IPV6_WARN_MARKER.exists() or not _has_ipv6():
+        return
+    IPV6_WARN_MARKER.touch()
+    threading.Thread(
+        target=lambda: show_info(_IPV6_WARNING, "TG WS Proxy"),
+        daemon=True,
+    ).start()
+
+
+# update check
+
+def maybe_notify_update(
+    cfg: dict,
+    is_exiting: Callable[[], bool],
+    ask_open: Callable[[str, str], bool],
+) -> None:
+    if not cfg.get("check_updates", True):
+        return
+
+    def _work():
+        time.sleep(1.5)
+        if is_exiting():
+            return
+        try:
+            from utils.update_check import RELEASES_PAGE_URL, get_status, run_check
+            import webbrowser
+
+            run_check(__version__)
+            st = get_status()
+            if not st.get("has_update"):
+                return
+            url = (st.get("html_url") or "").strip() or RELEASES_PAGE_URL
+            ver = st.get("latest") or "?"
+            if ask_open(
+                f"Доступна новая версия: {ver}\n\nОткрыть страницу релиза в браузере?",
+                "TG WS Proxy — обновление",
+            ):
+                webbrowser.open(url)
+        except Exception as exc:
+            log.debug("Update check failed: %s", exc)
+
+    threading.Thread(target=_work, daemon=True, name="update-check").start()
+
+
+# ctk thread (windows / linux)
+
+_ctk_root: Any = None
+_ctk_root_ready = threading.Event()
+
+
+def ensure_ctk_thread(ctk: Any, mode: str = "auto") -> bool:
+    global _ctk_root
+    if ctk is None:
+        return False
+    if _ctk_root_ready.is_set():
+        return True
+
+    def _run():
+        global _ctk_root
+        from ui.ctk_theme import apply_ctk_appearance, install_tkinter_variable_del_guard
+
+        install_tkinter_variable_del_guard()
+        apply_ctk_appearance(ctk, mode)
+        _ctk_root = ctk.CTk()
+        _ctk_root.withdraw()
+        _ctk_root_ready.set()
+        _ctk_root.mainloop()
+
+    threading.Thread(target=_run, daemon=True, name="ctk-root").start()
+    _ctk_root_ready.wait(timeout=5.0)
+    return _ctk_root is not None
+
+
+def ctk_run_dialog(build_fn: Callable[[threading.Event], None]) -> None:
+    if _ctk_root is None:
+        return
+    done = threading.Event()
+
+    def _invoke():
+        try:
+            build_fn(done)
+        except Exception:
+            log.exception("CTk dialog failed")
+            done.set()
+
+    _ctk_root.after(0, _invoke)
+    done.wait()
+    import gc
+    gc.collect()
+
+
+def quit_ctk() -> None:
+    if _ctk_root is not None:
+        try:
+            _ctk_root.after(0, _ctk_root.quit)
+        except Exception:
+            pass
+
+
+# common bootstrap
+
+def bootstrap(cfg: dict) -> None:
+    save_config(cfg)
+    if LOG_FILE.exists():
+        try:
+            LOG_FILE.unlink()
+        except Exception:
+            pass
+    setup_logging(
+        cfg.get("verbose", False),
+        log_max_mb=cfg.get("log_max_mb", DEFAULT_CONFIG["log_max_mb"]),
+    )
+    log.info("TG WS Proxy версия %s starting", __version__)
+    log.info("Config: %s", cfg)
+    log.info("Log file: %s", LOG_FILE)

utils/update_check.py

@@ -16,7 +16,7 @@ from typing import Any, Dict, Optional, Tuple
 from urllib.error import HTTPError, URLError
 from urllib.request import Request, urlopen
 
-REPO = "Dark-Avery/tg-ws-proxy"
+REPO = "Flowseal/tg-ws-proxy"
 RELEASES_LATEST_API = f"https://api.github.com/repos/{REPO}/releases/latest"
 RELEASES_PAGE_URL = f"https://github.com/{REPO}/releases/latest"
 

utils/win32_theme.py

@@ -0,0 +1,35 @@
+from __future__ import annotations
+
+import sys
+
+def is_windows_dark_theme() -> bool:
+    if sys.platform != "win32":
+        return False
+
+    try:
+        import winreg
+        key = winreg.OpenKey(winreg.HKEY_CURRENT_USER, r"Software\Microsoft\Windows\CurrentVersion\Themes\Personalize")
+        value, _ = winreg.QueryValueEx(key, "AppsUseLightTheme")
+        return value == 0
+    except Exception:
+        return False
+
+def apply_windows_dark_theme() -> None:
+    try:
+        import ctypes
+        uxtheme = ctypes.windll.uxtheme
+        
+        try:
+            set_preferred = uxtheme[135]
+            result = set_preferred(2)
+            if result == 0:
+                flush = uxtheme[136]
+                flush()
+        except Exception:
+            try:
+                allow_dark = uxtheme[135]
+                allow_dark(True)
+            except Exception:
+                pass
+    except Exception:
+        pass

windows.py

@@ -1,18 +1,12 @@
 from __future__ import annotations
 
 import ctypes
-import ipaddress
-import json
-import logging
-import logging.handlers
 import os
-import winreg
-import psutil
 import sys
 import threading
 import time
 import webbrowser
-import ipaddress
+import winreg
 from pathlib import Path
 from typing import Optional
 
@@ -32,169 +26,66 @@ except ImportError:
     ctk = None
 
 try:
-    from PIL import Image, ImageDraw, ImageFont
+    from PIL import Image
 except ImportError:
-    Image = ImageDraw = ImageFont = None
+    Image = None
 
-import proxy.tg_ws_proxy as tg_ws_proxy
+from proxy import get_link_host
-from proxy.app_runtime import ProxyAppRuntime
+
-from proxy import __version__
+from utils.win32_theme import (
-from utils.default_config import default_tray_config
+    is_windows_dark_theme, 
+    apply_windows_dark_theme,
+)
+from utils.tray_common import (
+    APP_NAME, DEFAULT_CONFIG, FIRST_RUN_MARKER, IS_FROZEN, LOG_FILE,
+    acquire_lock, bootstrap, check_ipv6_warning, ctk_run_dialog,
+    ensure_ctk_thread, ensure_dirs, load_config, load_icon, log,
+    maybe_notify_update, quit_ctk, release_lock, restart_proxy,
+    save_config, start_proxy, stop_proxy, tg_proxy_url,
+)
 from ui.ctk_tray_ui import (
-    install_tray_config_buttons,
+    install_tray_config_buttons, install_tray_config_form,
-    install_tray_config_form,
+    populate_first_run_window, tray_settings_scroll_and_footer,
-    populate_first_run_window,
-    tray_settings_scroll_and_footer,
     validate_config_form,
 )
 from ui.ctk_theme import (
-    CONFIG_DIALOG_FRAME_PAD,
+    CONFIG_DIALOG_FRAME_PAD, CONFIG_DIALOG_SIZE, FIRST_RUN_SIZE,
-    CONFIG_DIALOG_SIZE,
+    create_ctk_toplevel, ctk_theme_for_platform, main_content_frame,
-    FIRST_RUN_SIZE,
-    create_ctk_root,
-    ctk_theme_for_platform,
-    main_content_frame,
 )
 
-
-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 = default_tray_config()
-
-
 _tray_icon: Optional[object] = None
 _config: dict = {}
-_exiting: bool = False
+_exiting = False
-_lock_file_path: Optional[Path] = None
 
-log = logging.getLogger("tg-ws-tray")
+ICON_PATH = str(Path(__file__).parent / "icon.ico")
-_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
 
-_user32 = ctypes.windll.user32
+# win32 dialogs
-_user32.MessageBoxW.argtypes = [
+
-    ctypes.c_void_p,
+_u32 = ctypes.windll.user32
-    ctypes.c_wchar_p,
+_u32.MessageBoxW.argtypes = [ctypes.c_void_p, ctypes.c_wchar_p, ctypes.c_wchar_p, ctypes.c_uint]
-    ctypes.c_wchar_p,
+_u32.MessageBoxW.restype = ctypes.c_int
-    ctypes.c_uint,
+
-]
+_MB_OK_ERR = 0x10
-_user32.MessageBoxW.restype = ctypes.c_int
+_MB_OK_INFO = 0x40
+_MB_YESNO_Q = 0x24
+_IDYES = 6
 
 
-def _same_process(lock_meta: dict, proc: psutil.Process) -> bool:
+def _show_error(text: str, title: str = "TG WS Proxy — Ошибка") -> None:
-    try:
+    _u32.MessageBoxW(None, text, title, _MB_OK_ERR)
-        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:
-        for arg in proc.cmdline():
-            if "windows.py" in arg:
-                return True
-    except Exception:
-        pass
-
-    frozen = bool(getattr(sys, "frozen", False))
-    if frozen:
-        return (
-            os.path.basename(sys.executable).lower() == proc.name().lower()
-        )
-
-    return False
 
 
-def _release_lock():
+def _show_info(text: str, title: str = "TG WS Proxy") -> None:
-    global _lock_file_path
+    _u32.MessageBoxW(None, text, title, _MB_OK_INFO)
-    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:
+def _ask_yes_no(text: str, title: str = "TG WS Proxy") -> bool:
-    global _lock_file_path
+    return _u32.MessageBoxW(None, text, title, _MB_YESNO_Q) == _IDYES
-    _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():
+# autostart (registry)
-    _runtime.ensure_dirs()
 
-
+_RUN_KEY = r"Software\Microsoft\Windows\CurrentVersion\Run"
-def load_config() -> dict:
-    return _runtime.load_config()
-
-
-def save_config(cfg: dict):
-    _runtime.save_config(cfg)
-
-
-def setup_logging(verbose: bool = False, log_max_mb: float = 5):
-    _runtime.setup_logging(verbose, log_max_mb=log_max_mb)
-
-
-def _autostart_reg_name() -> str:
-    return APP_NAME
 
 
 def _supports_autostart() -> bool:
@@ -207,408 +98,213 @@ def _autostart_command() -> str:
 
 def is_autostart_enabled() -> bool:
     try:
-        with winreg.OpenKey(
+        with winreg.OpenKey(winreg.HKEY_CURRENT_USER, _RUN_KEY, 0, winreg.KEY_READ) as k:
-            winreg.HKEY_CURRENT_USER,
+            val, _ = winreg.QueryValueEx(k, APP_NAME)
-            r"Software\Microsoft\Windows\CurrentVersion\Run",
+        return str(val).strip() == _autostart_command().strip()
-            0,
+    except (FileNotFoundError, OSError):
-            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(
+        with winreg.CreateKey(winreg.HKEY_CURRENT_USER, _RUN_KEY) as k:
-            winreg.HKEY_CURRENT_USER,
-            r"Software\Microsoft\Windows\CurrentVersion\Run",
-        ) as k:
             if enabled:
-                winreg.SetValueEx(
+                winreg.SetValueEx(k, APP_NAME, 0, winreg.REG_SZ, _autostart_command())
-                    k,
-                    _autostart_reg_name(),
-                    0,
-                    winreg.REG_SZ,
-                    _autostart_command(),
-                )
             else:
                 try:
-                    winreg.DeleteValue(k, _autostart_reg_name())
+                    winreg.DeleteValue(k, APP_NAME)
                 except FileNotFoundError:
                     pass
     except OSError as exc:
         log.error("Failed to update autostart: %s", exc)
         _show_error(
             "Не удалось изменить автозапуск.\n\n"
-            "Попробуйте запустить приложение от имени пользователя с правами на реестр.\n\n"
+            "Попробуйте запустить приложение от имени пользователя "
-            f"Ошибка: {exc}"
+            f"с правами на реестр.\n\nОшибка: {exc}"
         )
 
 
-def _make_icon_image(size: int = 64):
+# tray callbacks
-    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("arial.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 _on_open_in_telegram(icon=None, item=None) -> None:
-
+    url = tg_proxy_url(_config)
-
-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 start_proxy():
-    _runtime.start_proxy(_config)
-
-
-def stop_proxy():
-    _runtime.stop_proxy()
-
-
-def restart_proxy():
-    _runtime.restart_proxy()
-
-
-def _show_error(text: str, title: str = "TG WS Proxy — Ошибка"):
-    _user32.MessageBoxW(None, text, title, 0x10)
-
-
-def _show_info(text: str, title: str = "TG WS Proxy"):
-    _user32.MessageBoxW(None, text, title, 0x40)
-
-
-def _ask_open_release_page(latest_version: str, url: str) -> bool:
-    """Win32 Yes/No: открыть страницу релиза."""
-    MB_YESNO = 0x4
-    MB_ICONQUESTION = 0x20
-    IDYES = 6
-    text = (
-        f"Доступна новая версия: {latest_version}\n\n"
-        f"Открыть страницу релиза в браузере?"
-    )
-    r = _user32.MessageBoxW(
-        None,
-        text,
-        "TG WS Proxy — обновление",
-        MB_YESNO | MB_ICONQUESTION,
-    )
-    return r == IDYES
-
-
-def _maybe_notify_update_async():
-    """
-    Фоновая проверка GitHub Releases и уведомление (не блокирует трей).
-    """
-    def _work():
-        time.sleep(1.5)
-        if _exiting:
-            return
-        if not _config.get("check_updates", True):
-            return
-        try:
-            from utils.update_check import RELEASES_PAGE_URL, get_status, run_check
-            run_check(__version__)
-            st = get_status()
-            if not st.get("has_update"):
-                return
-            url = (st.get("html_url") or "").strip() or RELEASES_PAGE_URL
-            ver = st.get("latest") or "?"
-            if _ask_open_release_page(str(ver), url):
-                webbrowser.open(url)
-        except Exception as exc:
-            log.debug("Update check failed: %s", exc)
-
-    threading.Thread(target=_work, daemon=True, name="update-check").start()
-
-
-def _on_open_in_telegram(icon=None, item=None):
-    host = _config.get("host", DEFAULT_CONFIG["host"])
-    port = _config.get("port", DEFAULT_CONFIG["port"])
-    url = f"tg://socks?server={host}&port={port}"
     log.info("Opening %s", url)
     try:
-        result = webbrowser.open(url)
+        if not webbrowser.open(url):
-        if not result:
+            raise RuntimeError
-            raise RuntimeError("webbrowser.open returned False")
     except Exception:
         log.info("Browser open failed, copying to clipboard")
         if pyperclip is None:
             _show_error(
                 "Не удалось открыть Telegram автоматически.\n\n"
-                f"Установите пакет pyperclip для копирования в буфер или откройте вручную:\n{url}")
+                f"Установите пакет pyperclip для копирования в буфер или откройте вручную:\n{url}"
+            )
             return
         try:
             pyperclip.copy(url)
             _show_info(
-                f"Не удалось открыть Telegram автоматически.\n\n"
+                "Не удалось открыть Telegram автоматически.\n\n"
-                f"Ссылка скопирована в буфер обмена, отправьте её в Telegram и нажмите по ней ЛКМ:\n{url}",
+                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):
+def _on_copy_link(icon=None, item=None) -> None:
-    threading.Thread(target=restart_proxy, daemon=True).start()
+    url = tg_proxy_url(_config)
+    log.info("Copying link: %s", url)
+    if pyperclip is None:
+        _show_error(
+            "Установите пакет pyperclip для копирования в буфер обмена."
+        )
+        return
+    try:
+        pyperclip.copy(url)
+    except Exception as exc:
+        log.error("Clipboard copy failed: %s", exc)
+        _show_error(f"Не удалось скопировать ссылку:\n{exc}")
 
 
-def _on_edit_config(icon=None, item=None):
+def _on_restart(icon=None, item=None) -> None:
+    threading.Thread(
+        target=lambda: restart_proxy(_config, _show_error), daemon=True
+    ).start()
+
+
+def _on_edit_config(icon=None, item=None) -> None:
     threading.Thread(target=_edit_config_dialog, daemon=True).start()
 
 
-def _edit_config_dialog():
+def _on_open_logs(icon=None, item=None) -> None:
-    if ctk is None:
-        _show_error("customtkinter не установлен.")
-        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)
-
-    theme = ctk_theme_for_platform()
-    w, h = CONFIG_DIALOG_SIZE
-    if _supports_autostart():
-        h += 100
-
-    icon_path = str(Path(__file__).parent / "icon.ico")
-
-    root = create_ctk_root(
-        ctk,
-        title="TG WS Proxy — Настройки",
-        width=w,
-        height=h,
-        theme=theme,
-        after_create=lambda r: r.iconbitmap(icon_path),
-    )
-
-    fpx, fpy = CONFIG_DIALOG_FRAME_PAD
-    frame = main_content_frame(ctk, root, theme, padx=fpx, pady=fpy)
-
-    scroll, footer = tray_settings_scroll_and_footer(ctk, frame, theme)
-
-    widgets = install_tray_config_form(
-        ctk,
-        scroll,
-        theme,
-        cfg,
-        DEFAULT_CONFIG,
-        show_autostart=_supports_autostart(),
-        autostart_value=cfg.get("autostart", False),
-    )
-
-    def on_save():
-        merged = validate_config_form(
-            widgets,
-            DEFAULT_CONFIG,
-            include_autostart=_supports_autostart(),
-        )
-        if isinstance(merged, str):
-            _show_error(merged)
-            return
-
-        new_cfg = merged
-        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()
-
-        # Win32 MessageBox из того же потока, что и mainloop CTk, блокирует обработку Tcl/Tk
-        # и даёт зависание; tkinter.messagebox согласован с циклом окна.
-        from tkinter import messagebox
-        if messagebox.askyesno("Перезапустить?",
-                               "Настройки сохранены.\n\n"
-                               "Перезапустить прокси сейчас?",
-                               parent=root):
-            root.destroy()
-            restart_proxy()
-        else:
-            root.destroy()
-
-    def on_cancel():
-        root.destroy()
-
-    install_tray_config_buttons(
-        ctk, footer, theme, on_save=on_save, on_cancel=on_cancel)
-
-    try:
-        root.mainloop()
-    finally:
-        import tkinter as tk
-        try:
-            if root.winfo_exists():
-                root.destroy()
-        except tk.TclError:
-            pass
-
-
-def _on_open_logs(icon=None, item=None):
     log.info("Opening log file: %s", LOG_FILE)
     if LOG_FILE.exists():
         os.startfile(str(LOG_FILE))
     else:
-        _show_info("Файл логов ещё не создан.", "TG WS Proxy")
+        _show_info("Файл логов ещё не создан.")
 
 
-def _on_exit(icon=None, item=None):
+def _on_exit(icon=None, item=None) -> None:
     global _exiting
     if _exiting:
         os._exit(0)
         return
     _exiting = True
     log.info("User requested exit")
-
+    quit_ctk()
-    def _force_exit():
+    threading.Thread(target=lambda: (time.sleep(3), os._exit(0)), daemon=True, name="force-exit").start()
-        time.sleep(3)
-        os._exit(0)
-    threading.Thread(target=_force_exit, daemon=True, name="force-exit").start()
-
     if icon:
         icon.stop()
 
 
+# settings dialog
 
-def _show_first_run():
+def _edit_config_dialog() -> None:
-    _ensure_dirs()
+    if not ensure_ctk_thread(ctk, _config.get("appearance", "auto")):
+        _show_error("customtkinter не установлен.")
+        return
+
+    cfg = dict(_config)
+    cfg["autostart"] = is_autostart_enabled()
+    if _supports_autostart() and not cfg["autostart"]:
+        set_autostart_enabled(False)
+
+    def _build(done: threading.Event) -> None:
+        theme = ctk_theme_for_platform()
+        w, h = CONFIG_DIALOG_SIZE
+        if _supports_autostart():
+            h += 100
+
+        root = create_ctk_toplevel(
+            ctk, title="TG WS Proxy — Настройки", width=w, height=h, theme=theme,
+            after_create=lambda r: r.iconbitmap(ICON_PATH),
+        )
+        fpx, fpy = CONFIG_DIALOG_FRAME_PAD
+        frame = main_content_frame(ctk, root, theme, padx=fpx, pady=fpy)
+        scroll, footer = tray_settings_scroll_and_footer(ctk, frame, theme)
+        widgets = install_tray_config_form(
+            ctk, scroll, theme, cfg, DEFAULT_CONFIG,
+            show_autostart=_supports_autostart(),
+            autostart_value=cfg.get("autostart", False),
+        )
+
+        def _finish() -> None:
+            root.destroy()
+            done.set()
+
+        def on_save() -> None:
+            from tkinter import messagebox
+            merged = validate_config_form(widgets, DEFAULT_CONFIG, include_autostart=_supports_autostart())
+            if isinstance(merged, str):
+                messagebox.showerror("TG WS Proxy — Ошибка", merged, parent=root)
+                return
+            save_config(merged)
+            _config.update(merged)
+            log.info("Config saved: %s", merged)
+            if _supports_autostart():
+                set_autostart_enabled(bool(merged.get("autostart", False)))
+            _tray_icon.menu = _build_menu()
+
+            do_restart = messagebox.askyesno(
+                "Перезапустить?",
+                "Настройки сохранены.\n\nПерезапустить прокси сейчас?",
+                parent=root,
+            )
+            _finish()
+            if do_restart:
+                threading.Thread(target=lambda: restart_proxy(_config, _show_error), daemon=True).start()
+
+        root.protocol("WM_DELETE_WINDOW", _finish)
+        install_tray_config_buttons(ctk, footer, theme, on_save=on_save, on_cancel=_finish)
+
+    ctk_run_dialog(_build)
+
+
+# first run
+
+def _show_first_run() -> None:
+    ensure_dirs()
     if FIRST_RUN_MARKER.exists():
         return
+    if not ensure_ctk_thread(ctk, _config.get("appearance", "auto")):
+        FIRST_RUN_MARKER.touch()
+        return
 
     host = _config.get("host", DEFAULT_CONFIG["host"])
     port = _config.get("port", DEFAULT_CONFIG["port"])
+    secret = _config.get("secret", DEFAULT_CONFIG["secret"])
 
-    if ctk is None:
+    def _build(done: threading.Event) -> None:
-        FIRST_RUN_MARKER.touch()
+        theme = ctk_theme_for_platform()
-        return
+        w, h = FIRST_RUN_SIZE
+        root = create_ctk_toplevel(
+            ctk, title="TG WS Proxy", width=w, height=h, theme=theme,
+            after_create=lambda r: r.iconbitmap(ICON_PATH),
+        )
 
-    theme = ctk_theme_for_platform()
+        def on_done(open_tg: bool) -> None:
-    icon_path = str(Path(__file__).parent / "icon.ico")
+            FIRST_RUN_MARKER.touch()
-    w, h = FIRST_RUN_SIZE
+            root.destroy()
-    root = create_ctk_root(
+            done.set()
-        ctk,
+            if open_tg:
-        title="TG WS Proxy",
+                _on_open_in_telegram()
-        width=w,
-        height=h,
-        theme=theme,
-        after_create=lambda r: r.iconbitmap(icon_path),
-    )
 
-    def on_done(open_tg: bool):
+        populate_first_run_window(ctk, root, theme, host=host, port=port, secret=secret, on_done=on_done)
-        FIRST_RUN_MARKER.touch()
-        root.destroy()
-        if open_tg:
-            _on_open_in_telegram()
 
-    populate_first_run_window(
+    ctk_run_dialog(_build)
-        ctk, root, theme, host=host, port=port, on_done=on_done)
-
-    try:
-        root.mainloop()
-    finally:
-        import tkinter as tk
-        try:
-            if root.winfo_exists():
-                root.destroy()
-        except tk.TclError:
-            pass
 
 
-def _has_ipv6_enabled() -> bool:
+# tray menu
-    import socket as _sock
-    try:
-        addrs = _sock.getaddrinfo(_sock.gethostname(), None, _sock.AF_INET6)
-        for addr in addrs:
-            ip = addr[4][0]
-            if not ip or ip.startswith("::1"):
-                continue
-            try:
-                if ipaddress.IPv6Address(ip).is_link_local:
-                    continue
-            except ValueError:
-                if ip.startswith("fe80:"):
-                    continue
-            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"])
+    link_host = get_link_host(host)
     return pystray.Menu(
-        pystray.MenuItem(
+        pystray.MenuItem(f"Открыть в Telegram ({link_host}:{port})", _on_open_in_telegram, default=True),
-            f"Открыть в Telegram ({host}:{port})",
+        pystray.MenuItem("Скопировать ссылку", _on_copy_link),
-            _on_open_in_telegram,
-            default=True),
         pystray.Menu.SEPARATOR,
         pystray.MenuItem("Перезапустить прокси", _on_restart),
         pystray.MenuItem("Настройки...", _on_edit_config),
@@ -618,23 +314,21 @@ def _build_menu():
     )
 
 
-def run_tray():
+# entry point
+
+def run_tray() -> None:
     global _tray_icon, _config
 
-    _config = _runtime.prepare()
+    _config = load_config()
-    _runtime.reset_log_file()
 
-    setup_logging(_config.get("verbose", False),
+    if is_windows_dark_theme:
-                  log_max_mb=_config.get("log_max_mb", DEFAULT_CONFIG["log_max_mb"]))
+        apply_windows_dark_theme()
-    log.info("TG WS Proxy версия %s, tray app starting", __version__)
+
-    log.info("Config: %s", _config)
+    bootstrap(_config)
-    log.info("Log file: %s", LOG_FILE)
 
     if pystray is None or Image is None or ctk is None:
-        log.error(
+        log.error("pystray, Pillow or customtkinter not installed; running in console mode")
-            "pystray, Pillow or customtkinter not installed; "
+        start_proxy(_config, _show_error)
-            "running in console mode")
-        start_proxy()
         try:
             while True:
                 time.sleep(1)
@@ -642,20 +336,12 @@ def run_tray():
             stop_proxy()
         return
 
-    start_proxy()
+    start_proxy(_config, _show_error)
-
+    maybe_notify_update(_config, lambda: _exiting, _ask_yes_no)
-    _maybe_notify_update_async()
-
     _show_first_run()
-    _check_ipv6_warning()
+    check_ipv6_warning(_show_info)
-
-    icon_image = _load_icon()
-    _tray_icon = pystray.Icon(
-        APP_NAME,
-        icon_image,
-        "TG WS Proxy",
-        menu=_build_menu())
 
+    _tray_icon = pystray.Icon(APP_NAME, load_icon(), "TG WS Proxy", menu=_build_menu())
     log.info("Tray icon running")
     _tray_icon.run()
 
@@ -663,15 +349,14 @@ def run_tray():
     log.info("Tray app exited")
 
 
-def main():
+def main() -> None:
-    if not _acquire_lock():
+    if not acquire_lock("windows.py"):
         _show_info("Приложение уже запущено.", os.path.basename(sys.argv[0]))
         return
-
     try:
         run_tray()
     finally:
-        _release_lock()
+        release_lock()
 
 
 if __name__ == "__main__":