hiddifypanel 10.11.1__py3-none-any.whl → 10.12.0__py3-none-any.whl

hiddifypanel/VERSION

@@ -1 +1 @@
-10.11.1
+10.12.0

hiddifypanel/VERSION.py

@@ -1,3 +1,3 @@
-__version__='10.11.1'
+__version__='10.12.0'
 from datetime import datetime
-__release_date__= datetime.strptime('2024-03-16','%Y-%m-%d')
+__release_date__= datetime.strptime('2024-03-19','%Y-%m-%d')

hiddifypanel/auth.py

@@ -143,9 +143,11 @@ def auth_before_request():
         # print(account)
         if not account:
             return logout_redirect()
-
-        next_url = request.url.replace(f'/{g.uuid}/', '/admin/' if is_admin_path else '/client/').replace("/admin/admin/",
-                                                                                                          '/admin/').replace("http://", "https://")
+        if is_admin_path:
+            next_url = request.url
+            next_url = next_url.replace(f'/{g.uuid}/', '/admin/')
+            next_url = next_url.replace("/admin/admin/", '/admin/')
+            next_url = next_url.replace("http://", "https://")
 
     elif apikey := request.headers.get("Hiddify-API-Key"):
         account = get_account_by_api_key(apikey, is_admin_path)
@@ -180,8 +182,16 @@ def auth_before_request():
         g.is_admin = hutils.flask.is_admin_role(account.role)  # type: ignore
         login_user(account, force=True)
         # print("loggining in")
-        if next_url is not None and g.user_agent['is_browser'] and ".webmanifest" not in request.path:
-            return redirect(next_url)
+        if not g.is_admin:
+            return
+        if next_url is None:
+            return
+        if not g.user_agent['is_browser']:
+            return
+        if ".webmanifest" in request.path:
+            return
+
+        return redirect(next_url)
 
 
 def logout_redirect():

hiddifypanel/hutils/encode.py

@@ -1,7 +1,6 @@
 import urllib.parse
 import base64
 import uuid
-import string
 from slugify import slugify
 
 

hiddifypanel/hutils/proxy/__init__.py

@@ -1,4 +1,5 @@
 from .shared import *
 from . import xray
+from . import xrayjson
 from . import singbox
 from . import clash

hiddifypanel/hutils/proxy/shared.py

@@ -259,6 +259,11 @@ def make_proxy(hconfigs: dict, proxy: Proxy, domain_db: Domain, phttp=80, ptls=4
     }
     if proxy.proto in ['tuic', 'hysteria2']:
         base['alpn'] = "h3"
+        if proxy.proto == 'hysteria2':
+            base['hysteria_up_mbps'] = hconfigs.get(ConfigEnum.hysteria_up_mbps)
+            base['hysteria_down_mbps'] = hconfigs.get(ConfigEnum.hysteria_down_mbps)
+            base['hysteria_obfs_enable'] = hconfigs.get(ConfigEnum.hysteria_obfs_enable)
+            base['hysteria_obfs_password'] = hconfigs.get(ConfigEnum.proxy_path)  # TODO: it should not be correct
         return base
     if proxy.proto in ['wireguard']:
         base['wg_pub'] = g.account.wg_pub
@@ -343,20 +348,18 @@ def make_proxy(hconfigs: dict, proxy: Proxy, domain_db: Domain, phttp=80, ptls=4
 
     if proxy.proto in {'vless', 'trojan', 'vmess'} and hconfigs.get(ConfigEnum.mux_enable):
         if hconfigs[ConfigEnum.mux_enable]:
-            base['mux_enable'] = True
-            base['mux_protocol'] = hconfigs[ConfigEnum.mux_protocol]
-            base['mux_max_connections'] = hconfigs[ConfigEnum.mux_max_connections]
-            base['mux_min_streams'] = hconfigs[ConfigEnum.mux_min_streams]
-            base['mux_max_streams'] = hconfigs[ConfigEnum.mux_max_streams]
-            base['mux_padding_enable'] = hconfigs[ConfigEnum.mux_padding_enable]
+            base['mux_enable'] = hconfigs[ConfigEnum.core_type]
 
-            # the hiddify next client doesn't support mux max streams
-            base['mux_max_streams'] = hconfigs[ConfigEnum.mux_max_streams]
+            base['mux_protocol'] = hconfigs.get(ConfigEnum.mux_protocol, "h2mux")
+            base['mux_max_connections'] = hconfigs.get(ConfigEnum.mux_max_connections, 0)
+            base['mux_min_streams'] = hconfigs.get(ConfigEnum.mux_min_streams, 0)
+            base['mux_max_streams'] = hconfigs.get(ConfigEnum.mux_max_streams, 0)
+            base['mux_padding_enable'] = hconfigs.get(ConfigEnum.mux_padding_enable)
 
             if hconfigs[ConfigEnum.mux_brutal_enable]:
                 base['mux_brutal_enable'] = True
-                base['mux_brutal_up_mbps'] = hconfigs[ConfigEnum.mux_brutal_up_mbps]
-                base['mux_brutal_down_mbps'] = hconfigs[ConfigEnum.mux_brutal_down_mbps]
+                base['mux_brutal_up_mbps'] = hconfigs.get(ConfigEnum.mux_brutal_up_mbps, 10)
+                base['mux_brutal_down_mbps'] = hconfigs.get(ConfigEnum.mux_brutal_down_mbps, 10)
 
     if is_cdn and proxy.proto in {'vless', 'trojan', "vmess"}:
         if hconfigs[ConfigEnum.tls_fragment_enable]:
@@ -366,6 +369,11 @@ def make_proxy(hconfigs: dict, proxy: Proxy, domain_db: Domain, phttp=80, ptls=4
 
         if hconfigs[ConfigEnum.tls_mixed_case]:
             base["tls_mixed_case"] = hconfigs[ConfigEnum.tls_mixed_case]
+            base['host'] = hutils.random.random_case(base['host'])
+            base['sni'] = hutils.random.random_case(base['sni'])
+            base['server'] = hutils.random.random_case(base['server'])
+            if base.get('fakedomain'):
+                base['fakedomain'] = hutils.random.random_case(base['fakedomain'])
 
         if hconfigs[ConfigEnum.tls_padding_enable]:
             base["tls_padding_enable"] = hconfigs[ConfigEnum.tls_padding_enable]

hiddifypanel/hutils/proxy/singbox.py

@@ -2,7 +2,7 @@ from flask import render_template, request, g
 import json
 
 from hiddifypanel import hutils
-from hiddifypanel.models import ProxyProto, ProxyTransport, Domain, ConfigEnum, hconfig
+from hiddifypanel.models import ProxyProto, ProxyTransport, Domain, ConfigEnum
 from hiddifypanel.panel.hiddify import is_hiddify_next_version
 
 
@@ -80,7 +80,7 @@ def to_singbox(proxy: dict) -> list[dict] | dict:
         base["uuid"] = proxy["uuid"]
 
     if proxy['proto'] in ['vmess', 'vless', 'trojan']:
-        add_multiplex(base)
+        add_multiplex(base, proxy)
 
     add_tls(base, proxy)
 
@@ -109,32 +109,33 @@ def to_singbox(proxy: dict) -> list[dict] | dict:
     return all_base
 
 
-def add_multiplex(base: dict):
-    if not hconfig(ConfigEnum.mux_enable):
+def add_multiplex(base: dict, proxy: dict):
+    if proxy.get('mux_enable') != "singbox":
         return
     base['multiplex'] = {
         "enabled": True,
-        "protocol": hconfig(ConfigEnum.mux_protocol),
-        "padding": hconfig(ConfigEnum.mux_padding_enable)
+        "protocol": proxy['mux_protocol'],
+        "padding": proxy['mux_padding_enable']
     }
     # Conflicts: max_streams with max_connections and min_streams
-    mux_max_streams = int(hconfig(ConfigEnum.mux_max_streams))
+    mux_max_streams = proxy.get('mux_max_streams', 0)
     if mux_max_streams and mux_max_streams != 0:
         base['multiplex']['max_streams'] = mux_max_streams
     else:
-        base['multiplex']['max_connections'] = int(hconfig(ConfigEnum.mux_max_connections))
-        base['multiplex']['min_streams'] = int(hconfig(ConfigEnum.mux_min_streams))
+        base['multiplex']['max_connections'] = proxy.get('mux_max_connections', 0)
+        base['multiplex']['min_streams'] = proxy.get('mux_min_streams', 0)
 
-    add_tcp_brutal(base)
+    add_tcp_brutal(base,proxy)
 
 
-def add_tcp_brutal(base: dict):
+def add_tcp_brutal(base: dict, proxy: dict):
     if 'multiplex' in base:
-        base['multiplex']['brutal'] = {
-            "enabled": hconfig(ConfigEnum.mux_brutal_enable),
-            "up_mbps": int(hconfig(ConfigEnum.mux_brutal_up_mbps)),
-            "down_mbps": int(hconfig(ConfigEnum.mux_brutal_down_mbps))
-        }
+        if proxy.get('mux_brutal_enable'):
+            base['multiplex']['brutal'] = {
+                "enabled": proxy.get('mux_brutal_enable', False),
+                "up_mbps": proxy.get('mux_brutal_up_mbps', 10),
+                "down_mbps": proxy.get('mux_brutal_down_mbps', 10)
+            }
 
 
 def add_udp_over_tcp(base: dict):
@@ -261,7 +262,7 @@ def add_shadowsocks_base(all_base: list[dict], proxy: dict):
     base["method"] = proxy["cipher"]
     base["password"] = proxy["password"]
     add_udp_over_tcp(base)
-    add_multiplex(base)
+    add_multiplex(base, proxy)
     if proxy["transport"] == "faketls":
         base["plugin"] = "obfs-local"
         base["plugin_opts"] = f'obfs=tls;obfs-host={proxy["fakedomain"]}'
@@ -327,12 +328,12 @@ def add_tuic(base: dict, proxy: dict):
 
 
 def add_hysteria(base: dict, proxy: dict):
-    base['up_mbps'] = int(hconfig(ConfigEnum.hysteria_up_mbps))
-    base['down_mbps'] = int(hconfig(ConfigEnum.hysteria_down_mbps))
+    base['up_mbps'] = proxy.get(ConfigEnum.hysteria_up_mbps)
+    base['down_mbps'] = proxy.get(ConfigEnum.hysteria_down_mbps)
     # TODO: check the obfs should be empty or not exists at all
-    if hconfig(ConfigEnum.hysteria_obfs_enable):
+    if proxy.get('hysteria_obfs_enable'):
         base['obfs'] = {
             "type": "salamander",
-            "password": hconfig(ConfigEnum.proxy_path)
+            "password": proxy.get('hysteria_obfs_password')
         }
     base['password'] = proxy['uuid']

hiddifypanel/hutils/proxy/xray.py

@@ -3,12 +3,22 @@ import json
 import copy
 from flask import render_template, request, g
 from hiddifypanel import hutils
-from hiddifypanel.models import Proxy, ProxyTransport, ProxyL3, ProxyCDN, ProxyProto, Domain, hconfig, ConfigEnum, DomainType
+from hiddifypanel.models import Proxy, ProxyTransport, ProxyL3, ProxyCDN, ProxyProto, Domain, ConfigEnum, DomainType, hconfig
 from flask_babel import gettext as _
 
 OUTBOUND_LEVEL = 8
 
 
+def is_muxable_agent(proxy: dict) -> bool:
+    if not proxy.get('mux_enable'):
+        return False
+    if proxy.get('mux_enable') == "xray" and g.user_agent.get('is_singbox'):
+        return False
+    if proxy.get('mux_enable') == "singbox" and not g.user_agent.get('is_singbox'):
+        return False
+    return True
+
+
 def to_link(proxy: dict) -> str | dict:
     if 'error' in proxy:
         return proxy
@@ -38,6 +48,7 @@ def to_link(proxy: dict) -> str | dict:
                       "sni": proxy["sni"],
                       "fp": proxy["fingerprint"]
                       }
+
         if 'reality' in proxy["l3"]:
             vmess_data['tls'] = "reality"
             vmess_data['pbk'] = proxy['reality_pbk']
@@ -77,7 +88,7 @@ def to_link(proxy: dict) -> str | dict:
             baseurl += "&allow_insecure=1"
         return f"{baseurl}#{name_link}"
     if proxy['proto'] == 'hysteria2':
-        baseurl = f'hysteria2://{proxy["uuid"]}@{proxy["server"]}:{proxy["port"]}?hiddify=1&obfs=salamander&obfs-password={hconfig(ConfigEnum.proxy_path)}&sni={proxy["sni"]}'
+        baseurl = f'hysteria2://{proxy["uuid"]}@{proxy["server"]}:{proxy["port"]}?hiddify=1&obfs=salamander&obfs-password={proxy["hysteria_obfs_password"]}&sni={proxy["sni"]}'
         if proxy['mode'] == 'Fake' or proxy['allow_insecure']:
             baseurl += "&insecure=1"
         return f"{baseurl}#{name_link}"
@@ -183,345 +194,6 @@ def make_v2ray_configs(user, user_activate, domains: list[Domain], expire_days,
     return "\n".join(res)
 
 
-def configs_as_json(domains: list[Domain], remarks: str) -> str:
-    '''Returns xray configs as json'''
-    outbounds = []
-    for proxy in hutils.proxy.get_valid_proxies(domains):
-        outbound = to_xray(proxy)
-        if 'msg' not in outbound:
-            outbounds.append(outbound)
-
-    outbounds_len = len(outbounds)
-    # reutrn no outbound
-    if outbounds_len < 1:
-        return ''
-
-    all_configs = []
-    base_config = json.loads(render_template('base_xray_config.json.j2', remarks=remarks))
-    # multiple outbounds needs multiple whole base config not just one with multiple outbounds (at least for v2rayng)
-    # https://github.com/2dust/v2rayNG/pull/2827#issue-2127534078
-    if outbounds_len > 1:
-        for out in outbounds:
-            base_config['remarks'] = out['tag']
-            base_config['outbounds'].insert(0, out)
-            all_configs.append(copy.deepcopy(base_config))
-            del base_config['outbounds'][0]
-    else:  # single outbound
-        base_config['outbounds'].insert(0, outbounds[0])
-        all_configs = base_config
-
-    json_configs = json.dumps(all_configs, indent=2, cls=hutils.proxy.ProxyJsonEncoder)
-    return json_configs
-
-
-def to_xray(proxy: dict) -> dict:
-    outbound = {
-        'tag': f'{proxy["extra_info"]} {proxy["name"]} § {proxy["port"]} {proxy["dbdomain"].id}',
-        'protocol': str(proxy['proto']),
-        'settings': {},
-        'streamSettings': {},
-        'mux': {  # default value
-            'enabled': False,
-            'concurrency': -1
-        }
-    }
-    # add multiplex to outbound
-    add_multiplex(outbound)
-
-    # add stream setting to outbound
-    add_stream_settings(outbound, proxy)
-
-    # add protocol settings to outbound
-    add_proto_settings(outbound, proxy)
-
-    return outbound
-
-# region proto settings
-
-
-def add_proto_settings(base: dict, proxy: dict):
-    if proxy['proto'] == ProxyProto.wireguard:
-        add_wireguard_settings(base, proxy)
-    elif proxy['proto'] == ProxyProto.ss:
-        add_shadowsocks_settings(base, proxy)
-    elif proxy['proto'] == ProxyProto.vless:
-        add_vless_settings(base, proxy)
-    elif proxy['proto'] == ProxyProto.vmess:
-        add_vmess_settings(base, proxy)
-    elif proxy['proto'] == ProxyProto.trojan:
-        proxy['password'] = proxy['uuid']
-        add_trojan_settings(base, proxy)
-
-
-def add_wireguard_settings(base: dict, proxy: dict):
-
-    base['settings']['secretKey'] = proxy['wg_pk']
-    base['settings']['reversed'] = [0, 0, 0]
-    base['settings']['mtu'] = 1380  # optional
-    base['settings']['peers'] = [{
-        'endpoint': f'{proxy["server"]}:{int(proxy["port"])}',
-        'publicKey': proxy["wg_server_pub"]
-        # 'allowedIPs':'', 'preSharedKey':'', 'keepAlive':'' # optionals
-    }]
-
-    # optionals
-    # base['settings']['address'] = [f'{proxy["wg_ipv4"]}/32',f'{proxy["wg_ipv6"]}/128']
-    # base['settings']['workers'] = 4
-    # base['settings']['domainStrategy'] = 'ForceIP' # default
-
-
-def add_vless_settings(base: dict, proxy: dict):
-    base['settings']['vnext'] = [
-        {
-            'address': proxy['server'],
-            'port': proxy['port'],
-            "users": [
-                {
-                    'id': proxy['uuid'],
-                    'encryption': 'none',
-                    # 'security': 'auto',
-                    'flow': 'xtls-rprx-vision' if (proxy['transport'] == ProxyTransport.XTLS or base['streamSettings']['security'] == 'reality') else '',
-                    'level': OUTBOUND_LEVEL
-                }
-            ]
-        }
-    ]
-
-
-def add_vmess_settings(base: dict, proxy: dict):
-    base['settings']['vnext'] = [
-        {
-            "address": proxy['server'],
-            "port": proxy['port'],
-            "users": [
-                {
-                    "id": proxy['uuid'],
-                    "security": proxy['cipher'],
-                    "level": OUTBOUND_LEVEL
-                }
-            ]
-        }
-    ]
-
-
-def add_trojan_settings(base: dict, proxy: dict):
-    base['settings']['servers'] = [
-        {
-            # 'email': proxy['uuid'], optional
-            'address': proxy['server'],
-            'port': proxy['port'],
-            'password': proxy['password'],
-            'level': OUTBOUND_LEVEL
-        }
-    ]
-
-
-def add_shadowsocks_settings(base: dict, proxy: dict):
-    base['settings']['servers'] = [
-        {
-            'address': proxy['server'],
-            'port': proxy['port'],
-            'method': proxy['cipher'],
-            'password': proxy['password'],
-            'uot': True,
-            'level': OUTBOUND_LEVEL
-            # 'email': '', optional
-        }
-    ]
-
-# endregion
-
-
-# region stream settings
-
-def add_stream_settings(base: dict, proxy: dict):
-    ss = base['streamSettings']
-    ss['security'] = 'none'  # default
-
-    # security
-    if proxy['l3'] == ProxyL3.reality:
-        ss['security'] = 'reality'
-    elif proxy['l3'] in [ProxyL3.tls, ProxyL3.tls_h2, ProxyL3.tls_h2_h1]:
-        ss['security'] = 'tls'
-
-    # network and transport settings
-    if ss['security'] == 'tls' or 'xtls':
-        ss['tlsSettings'] = {
-            'serverName': proxy['sni'],
-            'allowInsecure': proxy['allow_insecure'],
-            'fingerprint': proxy['fingerprint'],
-            'alpn': [proxy['alpn']],
-            # 'minVersion': '1.2',
-            # 'disableSystemRoot': '',
-            # 'enableSessionResumption': '',
-            # 'pinnedPeerCertificateChainSha256': '',
-            # 'certificates': '',
-            # 'maxVersion': '1.3', # Go lang sets
-            # 'cipherSuites': '', # Go lang sets
-            # 'rejectUnknownSni': '', # default is false
-        }
-    if ss['security'] == 'reality':
-        ss['network'] = proxy['transport']
-        add_reality_stream(ss, proxy)
-    if proxy['l3'] == ProxyL3.kcp:
-        ss['network'] = 'kcp'
-        add_kcp_stream(ss, proxy)
-
-    if proxy['l3'] == ProxyL3.h3_quic:
-        add_quic_stream(ss, proxy)
-
-    if proxy['transport'] == 'tcp' or ss['security'] == 'reality' or (ss['security'] == 'none' and proxy['transport'] not in [ProxyTransport.httpupgrade, ProxyTransport.WS]):
-        ss['network'] = proxy['transport']
-        add_tcp_stream(ss, proxy)
-    if proxy['transport'] == ProxyTransport.h2 and ss['security'] == 'none' and ss['security'] != 'reality':
-        ss['network'] = proxy['transport']
-        add_http_stream(ss, proxy)
-    if proxy['transport'] == ProxyTransport.grpc:
-        ss['network'] = proxy['transport']
-        add_grpc_stream(ss, proxy)
-    if proxy['transport'] == ProxyTransport.httpupgrade:
-        ss['network'] = proxy['transport']
-        add_httpupgrade_stream(ss, proxy)
-    if proxy['transport'] == 'ws':
-        ss['network'] = proxy['transport']
-        add_ws_stream(ss, proxy)
-
-    # tls fragmentaion
-    add_tls_fragmentation_stream_settings(base)
-
-
-def add_tcp_stream(ss: dict, proxy: dict):
-    if proxy['l3'] == ProxyL3.http:
-        ss['tcpSettings'] = {
-            'header': {
-                'type': 'http',
-                'request': {
-                    'path': [proxy['path']]
-                }
-            }
-            # 'acceptProxyProtocol': False
-        }
-    else:
-        ss['tcpSettings'] = {
-            'header': {
-                'type': 'none'
-            }
-            # 'acceptProxyProtocol': False
-        }
-
-
-def add_http_stream(ss: dict, proxy: dict):
-    ss['httpSettings'] = {
-        'host': proxy['host'],
-        'path': proxy['path'],
-        # 'read_idle_timeout': 10,  # default disabled
-        # 'health_check_timeout': 15,  # default is 15
-        # 'method': 'PUT',  # default is 15
-        # 'headers': {
-
-        # }
-    }
-
-
-def add_ws_stream(ss: dict, proxy: dict):
-    ss['wsSettings'] = {
-        'path': proxy['path'],
-        'headers': {
-            "Host": proxy['host']
-        }
-        # 'acceptProxyProtocol': False,
-    }
-
-
-def add_grpc_stream(ss: dict, proxy: dict):
-    ss['grpcSettings'] = {
-        'serviceName': proxy['path'],  # proxy['path'] is equal toproxy['grpc_service_name']
-        'idle_timeout': 115,  # by default, the health check is not enabled. may solve some "connection drop" issues
-        'health_check_timeout': 20,  # default is 20
-        # 'initial_windows_size': 0,  # 0 means disabled. greater than 65535 means Dynamic Window mechanism will be disabled
-        # 'permit_without_stream': False, # health check performed when there are no sub-connections
-        # 'multiMode': false, # experimental
-    }
-
-
-def add_httpupgrade_stream(ss: dict, proxy: dict):
-    ss['httpupgradeSettings'] = {
-        'path': proxy['path'],
-        'host': proxy['host'],
-        # 'acceptProxyProtocol': '', for inbounds only
-    }
-
-
-def add_kcp_stream(ss: dict, proxy: dict):
-    # TODO: fix server side configs first
-    ss['kcpSettings'] = {}
-    return
-    ss['kcpSettings'] = {
-        'seed': proxy['path'],
-        # 'mtu': 1350, # optional, default value is written
-        # 'tti': 50, # optional, default value is written
-        # 'uplinkCapacity': 5, # optional, default value is written
-        # 'downlinkCapacity': 20, # optional, default value is written
-        # 'congestion':False, # optional, default value is written
-        # 'readBufferSize': 2,# optional, default value is written
-        # 'writeBufferSize':2 # optional, default value is written
-        # 'header': { # must be same as server (hiddify doesn't use yet)
-        #     'type': 'none'  # choices: none(default), srtp, utp, wechat-video, dtls, wireguards
-        # }
-    }
-
-
-def add_quic_stream(ss: dict, proxy: dict):
-    # TODO: fix server side configs first
-    ss['quicSettings'] = {}
-    return
-    ss['quicSettings'] = {
-        'security': 'chacha20-poly1305',
-        'key': proxy['path'],
-        'header': {
-            'type': 'none'
-        }
-    }
-
-
-def add_reality_stream(ss: dict, proxy: dict):
-    ss['realitySettings'] = {
-        'serverName': proxy['sni'],
-        'fingerprint': proxy['fingerprint'],
-        'shortId': proxy['reality_short_id'],
-        'publicKey': proxy['reality_pbk'],
-        'show': False,
-    }
-
-
-def add_tls_fragmentation_stream_settings(base: dict):
-    '''Adds tls fragment in the outbounds if tls fragmentation is enabled'''
-    if base['streamSettings']['security'] in ['tls', 'reality']:
-        if hconfig(ConfigEnum.tls_fragment_enable):
-            base['streamSettings']['sockopt'] = {
-                'dialerProxy': 'fragment',
-                'tcpKeepAliveIdle': 100,
-                'tcpNoDelay': True,  # recommended to be enabled with "tcpMptcp": true.
-                "mark": 255
-                # 'tcpFastOpen': True, # the system default setting be used.
-                # 'tcpKeepAliveInterval': 0, # 0 means default GO lang settings, -1 means not enable
-                # 'tcpcongestion': bbr, # Not configuring means using the system default value
-                # 'tcpMptcp': True, # need to be enabled in both server and client configuration (not supported by panel yet)
-            }
-
-# endregion
-
-
-def add_multiplex(base: dict):
-    if hconfig(ConfigEnum.mux_enable):
-        concurrency = hutils.convert.to_int(hconfig(ConfigEnum.mux_max_connections))
-        if concurrency and concurrency > 0:
-            base['mux']['enabled'] = True
-            base['mux']['concurrency'] = concurrency
-            base['mux']['xudpConcurrency'] = concurrency
-            base['mux']['xudpProxyUDP443'] = 'reject'
-
-
 def add_tls_tricks_to_dict(d: dict, proxy: dict):
     if proxy.get('tls_fragment_enable'):
         if g.user_agent.get('is_shadowrocket'):
@@ -536,17 +208,19 @@ def add_tls_tricks_to_dict(d: dict, proxy: dict):
 
 
 def add_mux_to_dict(d: dict, proxy):
-    if proxy.get('mux_enable'):
-        # according to github.com/hiddify/ray2sing/
-        d['muxtype'] = proxy["mux_protocol"]
-        d['muxmaxc'] = proxy["mux_max_connections"]
-        d['mux'] = proxy['mux_min_streams']
-        d['muxsmax'] = proxy["mux_max_streams"]
-        d['muxpad'] = proxy["mux_padding_enable"]
-
-        if proxy.get('mux_brutal_enable'):
-            d['muxup'] = proxy["mux_brutal_up_mbps"]
-            d['muxdown'] = proxy["mux_brutal_down_mbps"]
+    if not is_muxable_agent(proxy):
+        return
+
+    # according to github.com/hiddify/ray2sing/
+    d['muxtype'] = proxy["mux_protocol"]
+    d['muxmaxc'] = proxy["mux_max_connections"]
+    d['mux'] = proxy['mux_min_streams']
+    d['muxsmax'] = proxy["mux_max_streams"]
+    d['muxpad'] = proxy["mux_padding_enable"]
+
+    if proxy.get('mux_brutal_enable'):
+        d['muxup'] = proxy["mux_brutal_up_mbps"]
+        d['muxdown'] = proxy["mux_brutal_down_mbps"]
 
 
 def add_tls_tricks_to_link(proxy: dict) -> str: