hiddifypanel 10.11.1__tar.gz → 10.12.0__tar.gz

{hiddifypanel-10.11.1 → hiddifypanel-10.12.0}/HISTORY.md

@@ -1,6 +1,94 @@
 # Changelog
 
 
+## v10.12.0 (2024-03-19)
+
+#### New
+
+* Add norooz. 
+
+#### Changes
+
+* Hiddify next download urls. 
+
+#### Fix
+
+* Reality ASN checking bug. 
+
+* Tcp brutal. 
+
+* Bug. 
+
+* Proxy status. 
+
+#### Other
+
+* Merge pull request #140 from Iam54r1n4/dev-patch21. 
+  _Change hiddify client(next) download urls_
+
+* Merge pull request #179 from MRDOCTOROO/main. 
+  _Update translations_
+
+* Fink 🐦: update translations. 
+
+* Merge branch 'hiddify:main' into main. 
+
+* Fink 🐦: update translations. 
+
+* Merge pull request #180 from Iam54r1n4/dev-patch49. 
+  _Fix reality ASN checking bug_
+
+* Merge pull request #181 from pjrobertson/macos_link. 
+  _Fix 2nd link to mac os download_
+
+* Fix up all URLs for hiddify clash desktop. 
+  _See the actual URLs in https://github.com/hiddify/HiddifyClashDesktop/releases - it contains 'v' before the first version number_
+
+* Fix 2nd link to mac os download. 
+  _Really fixes #3820 - also makes the code DRY so as to improve maintainability_
+
+* Fink 🐦: update translations. 
+
+* Fink 🐦: update translations. 
+
+* Fink 🐦: update translations. 
+
+* Fink 🐦: update translations. 
+
+* Better auth. 
+
+* Merge pull request #178 from Iam54r1n4/dev-patch48. 
+  _Fix sub bug_
+
+* Some refactor for multi node. 
+
+* Update translations. 
+
+* Merge branch 'main' of github.com:hiddify/Hiddify-Panel. 
+
+* Merge pull request #175 from Iam54r1n4/dev-patch46. 
+  _Add mixed case domains in client configs_
+
+* Add: mixed case domains in client configs all client don't support mixed case feature internally. 
+
+* Merge pull request #176 from Arbelin94/main. 
+  _Update translations_
+
+* Fink 🐦: update translations. 
+
+* Fink 🐦: update translations. 
+
+* Merge pull request #177 from Iam54r1n4/dev-patch47. 
+  _Add sending telegram msg to selected users_
+
+* Update user_list.html. 
+
+* Add: sending telegram msg to selected users. 
+
+* Disable redirect for clients. 
+
+
+
 ## v10.11.1 (2024-03-16)
 
 #### Changes

{hiddifypanel-10.11.1 → hiddifypanel-10.12.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: hiddifypanel
-Version: 10.11.1
+Version: 10.12.0
 Summary: hiddifypanel multi proxy panel
 Home-page: https://github.com/hiddify/hiddify-manager/
 Author: hiddify

hiddifypanel-10.12.0/hiddifypanel/VERSION

@@ -0,0 +1 @@
+10.12.0

hiddifypanel-10.12.0/hiddifypanel/VERSION.py

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

{hiddifypanel-10.11.1 → hiddifypanel-10.12.0}/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-10.11.1 → hiddifypanel-10.12.0}/hiddifypanel/hutils/encode.py

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

{hiddifypanel-10.11.1 → hiddifypanel-10.12.0}/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-10.11.1 → hiddifypanel-10.12.0}/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-10.11.1 → hiddifypanel-10.12.0}/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-10.12.0/hiddifypanel/hutils/proxy/xray.py

@@ -0,0 +1,235 @@
+import datetime
+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, 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
+
+    orig_name_link = (proxy['extra_info'] + " " + proxy["name"]).strip()
+    name_link = hutils.encode.url_encode(orig_name_link)
+    if proxy['proto'] == 'vmess':
+        # print(proxy)
+        vmess_type = None
+        if proxy["transport"] == 'tcp':
+            vmess_type = 'http'
+        if 'grpc_mode' in proxy:
+            vmess_type = proxy['grpc_mode']
+        vmess_data = {"v": "2",
+                      "ps": orig_name_link,
+                      "add": proxy['server'],
+                      "port": proxy['port'],
+                      "id": proxy["uuid"],
+                      "aid": 0,
+                      "scy": proxy['cipher'],
+                      "net": proxy["transport"],
+                      "type": vmess_type or "none",
+                      "host": proxy.get("host", ""),
+                      "alpn": proxy.get("alpn", "h2,http/1.1"),
+                      "path": proxy["path"] if "path" in proxy else "",
+                      "tls": "tls" if "tls" in proxy["l3"] else "",
+                      "sni": proxy["sni"],
+                      "fp": proxy["fingerprint"]
+                      }
+
+        if 'reality' in proxy["l3"]:
+            vmess_data['tls'] = "reality"
+            vmess_data['pbk'] = proxy['reality_pbk']
+            vmess_data['sid'] = proxy['reality_short_id']
+
+        add_tls_tricks_to_dict(vmess_data, proxy)
+        add_mux_to_dict(vmess_data, proxy)
+
+        return "vmess://" + hutils.encode.do_base_64(f'{json.dumps(vmess_data,cls=hutils.proxy.ProxyJsonEncoder)}')
+    if proxy['proto'] == 'ssh':
+        baseurl = 'ssh://'
+        if g.user_agent.get('is_streisand'):
+            streisand_ssh = hutils.encode.do_base_64(f'{proxy["uuid"]}:0:{proxy["private_key"]}::@{proxy["server"]}:{proxy["port"]}')
+            baseurl += f'{streisand_ssh}#{name_link}'
+        else:
+            hk = ",".join(proxy["host_key"])
+            pk = proxy["private_key"].replace('\n', '')
+            baseurl += f'{proxy["uuid"]}@{proxy["server"]}:{proxy["port"]}/?file=ssh&pk={pk}&hk={hk}#{name_link}'
+
+        return baseurl
+    if proxy['proto'] == "ssr":
+        baseurl = f'ssr://{proxy["cipher"]}:{proxy["uuid"]}@{proxy["server"]}:{proxy["port"]}'
+        return baseurl
+    if proxy['proto'] in ['ss', 'v2ray']:
+        baseurl = f'ss://{proxy["cipher"]}:{proxy["password"]}@{proxy["server"]}:{proxy["port"]}'
+        if proxy['mode'] == 'faketls':
+            return f'{baseurl}?plugin=obfs-local%3Bobfs%3Dtls%3Bobfs-host%3D{proxy["fakedomain"]}%3Budp-over-tcp=true#{name_link}'
+        # if proxy['mode'] == 'shadowtls':
+        #     return f'{baseurl}?plugin=shadow-tls%3Bpassword%3D{proxy["proxy_path"]}%3Bhost%3D{proxy["fakedomain"]}%3Budp-over-tcp=true#{name_link}'
+        if proxy['proto'] == 'v2ray':
+            return f'{baseurl}?plugin=v2ray-plugin%3Bmode%3Dwebsocket%3Bpath%3D{proxy["path"]}%3Bhost%3D{proxy["host"]}%3Btls%3Budp-over-tcp=true#{name_link}'
+        if proxy['transport'] == 'shadowsocks':
+            return baseurl
+    if proxy['proto'] == 'tuic':
+        baseurl = f'tuic://{proxy["uuid"]}:{proxy["uuid"]}@{proxy["server"]}:{proxy["port"]}?congestion_control=cubic&udp_relay_mode=native&sni={proxy["sni"]}&alpn=h3'
+        if proxy['mode'] == 'Fake' or proxy['allow_insecure']:
+            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={proxy["hysteria_obfs_password"]}&sni={proxy["sni"]}'
+        if proxy['mode'] == 'Fake' or proxy['allow_insecure']:
+            baseurl += "&insecure=1"
+        return f"{baseurl}#{name_link}"
+    if proxy['proto'] == ProxyProto.wireguard:
+        if g.user_agent.get('is_streisand'):
+            return f'wireguard://{proxy["server"]}:{proxy["port"]}?private_key={proxy["wg_pk"]}&peer_public_key={proxy["wg_server_pub"]}&pre_shared_key={proxy["wg_psk"]}&reserved=0,0,0#{name_link}'
+        else:
+            # hiddify_format =
+            # f'wg://{proxy["server"]}:{proxy["port"]}/?pk={proxy["wg_pk"]}&local_address={proxy["wg_ipv4"]}/32&peer_pk={proxy["wg_server_pub"]}&pre_shared_key={proxy["wg_psk"]}&workers=4&mtu=1380&reserved=0,0,0&ifp={proxy["wg_noise_trick"]}#{name_link}'
+            return f'wg://{proxy["server"]}:{proxy["port"]}?publicKey={proxy["wg_pub"]}&privateKey={proxy["wg_pk"]}=&presharedKey={proxy["wg_psk"]}&ip=10.0.0.1&mtu=1380&keepalive=30&udp=1&reserved=0,0,0&ifp={proxy["wg_noise_trick"]}#{name_link}'
+
+    baseurl = f'{proxy["proto"]}://{proxy["uuid"]}@{proxy["server"]}:{proxy["port"]}?hiddify=1'
+    baseurl += f'&sni={proxy["sni"]}&type={proxy["transport"]}'
+    baseurl += f"&alpn={proxy['alpn']}"
+
+    # the ray2sing supports vless, vmess and trojan tls tricks and mux
+    # the vmess handled already
+
+    baseurl += add_mux_to_link(proxy)
+    baseurl += add_tls_tricks_to_link(proxy)
+
+    # infos+=f'&alpn={proxy["alpn"]}'
+    baseurl += f'&path={proxy["path"]}' if "path" in proxy else ""
+    baseurl += f'&host={proxy["host"]}' if "host" in proxy else ""
+    if "grpc" == proxy["transport"]:
+        baseurl += f'&serviceName={proxy["grpc_service_name"]}&mode={proxy["grpc_mode"]}'
+    # print(proxy['cdn'],proxy["transport"])
+    if request.args.get("fragment"):
+        baseurl += f'&fragment=' + request.args.get("fragment")  # type: ignore
+    if "ws" == proxy["transport"] and proxy['cdn'] and request.args.get("fragment_v1"):
+        baseurl += f'&fragment_v1=' + request.args.get("fragment_v1")  # type: ignore
+    if 'vless' == proxy['proto']:
+        baseurl += "&encryption=none"
+    if proxy.get('fingerprint', 'none') != 'none':
+        baseurl += "&fp=" + proxy['fingerprint']
+    if proxy['l3'] != 'quic':
+        if proxy.get('l3') != ProxyL3.reality and (proxy.get('transport') == ProxyTransport.tcp or proxy.get('transport') == ProxyTransport.httpupgrade) and proxy['proto'] in [ProxyProto.vless, ProxyProto.trojan]:
+            baseurl += '&headerType=http'
+        else:
+            baseurl += '&headerType=None'
+    if proxy['mode'] == 'Fake' or proxy['allow_insecure']:
+        baseurl += "&allowInsecure=true"
+    if proxy.get('flow'):
+        baseurl += f'&flow={proxy["flow"]}'
+
+    infos = f'#{name_link}'
+
+    if 'reality' in proxy["l3"]:
+        return f"{baseurl}&security=reality&pbk={proxy['reality_pbk']}&sid={proxy['reality_short_id']}{infos}"
+    if 'tls' in proxy['l3']:
+        return f'{baseurl}&security=tls{infos}'
+    if proxy['l3'] == 'http':
+        return f'{baseurl}&security=none{infos}'
+    return proxy
+
+
+def make_v2ray_configs(user, user_activate, domains: list[Domain], expire_days, ip_debug, db_domain, has_auto_cdn, asn, profile_title, **kwargs) -> str:
+    res = []
+
+    ua = hutils.flask.get_user_agent()
+    if hconfig(ConfigEnum.show_usage_in_sublink):
+
+        if not ua['is_hiddify']:
+
+            fake_ip_for_sub_link = datetime.datetime.now().strftime(f"%H.%M--%Y.%m.%d.time:%H%M")
+            # if ua['app'] == "Fair1":
+            #     res.append(f'trojan://1@{fake_ip_for_sub_link}?sni=fake_ip_for_sub_link&security=tls#{round(user.current_usage_GB,3)}/{user.usage_limit_GB}GB_Remain:{expire_days}days')
+            # else:
+
+            # res.append(f'trojan://1@{fake_ip_for_sub_link}?sni=fake_ip_for_sub_link&security=tls#{hutils.encode.url_encode(profile_title)}')
+
+            name = '⏳' if user_activate else '✖'
+            if user.usage_limit_GB < 1000:
+                name += f'{round(user.current_usage_GB,3)}/{str(user.usage_limit_GB).replace(".0","")}GB'
+            elif user.usage_limit_GB < 100000:
+                name += f'{round(user.current_usage_GB/1000,3)}/{str(round(user.usage_limit_GB/1000,1)).replace(".0","")}TB'
+            else:
+                res.append("#No Usage Limit")
+            if expire_days < 1000:
+                name += " " + _(f'📅%(expire_days)s days', expire_days=expire_days)
+            else:
+                res.append("#No Time Limit")
+
+            name = name.strip()
+            if len(name) > 3:
+                res.append(f'trojan://1@{fake_ip_for_sub_link}?sni=fake_ip_for_sub_link&security=tls#{hutils.encode.url_encode(name)}')
+
+    if ua['is_browser']:
+        res.append(f'#Hiddify auto ip: {ip_debug}')
+
+    if not user_activate:
+
+        if hconfig(ConfigEnum.lang) == 'fa':
+            res.append('trojan://1@1.1.1.1#' + hutils.encode.url_encode('✖بسته شما به پایان رسید'))
+        else:
+            res.append('trojan://1@1.1.1.1#' + hutils.encode.url_encode('✖Package_Ended'))
+        return "\n".join(res)
+
+    for pinfo in hutils.proxy.get_valid_proxies(domains):
+        link = to_link(pinfo)
+        if 'msg' not in link:
+            res.append(link)
+    return "\n".join(res)
+
+
+def add_tls_tricks_to_dict(d: dict, proxy: dict):
+    if proxy.get('tls_fragment_enable'):
+        if g.user_agent.get('is_shadowrocket'):
+            d['fragment'] = f'1,{proxy["tls_fragment_size"]},{proxy["tls_fragment_sleep"]}'
+        else:
+            d['fragment'] = f'{proxy["tls_fragment_size"]},{proxy["tls_fragment_sleep"]},tlshello'
+
+    if proxy.get("tls_mixed_case"):
+        d['mc'] = 1
+    if proxy.get("tls_padding_enable"):
+        d['padsize'] = proxy["tls_padding_length"]
+
+
+def add_mux_to_dict(d: dict, proxy):
+    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:
+    out = {}
+    add_tls_tricks_to_dict(out, proxy)
+    return hutils.encode.convert_dict_to_url(out)
+
+
+def add_mux_to_link(proxy: dict) -> str:
+    out = {}
+    add_mux_to_dict(out, proxy)
+    return hutils.encode.convert_dict_to_url(out)