hiddifypanel 10.20.4__py3-none-any.whl → 10.30.0.dev0__py3-none-any.whl

hiddifypanel/VERSION

@@ -1 +1 @@
-10.20.4
+10.30.0.dev0

hiddifypanel/VERSION.py

@@ -1,3 +1,3 @@
-__version__='10.20.4'
+__version__='10.30.0.dev0'
 from datetime import datetime
-__release_date__= datetime.strptime('2024-04-13','%Y-%m-%d')
+__release_date__= datetime.strptime('2024-06-24','%Y-%m-%d')

hiddifypanel/base.py

@@ -18,6 +18,22 @@ from loguru import logger
 from hiddifypanel.panel.init_db import init_db
 
 
+def init_logger():
+    def dynamic_formatter(record) -> str:
+        fmt = '<green>{time:YYYY-MM-DD HH:mm:ss}</green> | <level>{level: <8}</level> | <cyan>{name}</cyan>:<cyan>{function}</cyan>:<cyan>{line}</cyan> - <level>{message}</level>'
+        if record['extra']:
+            fmt += ' | <level>{extra}</level>'
+        return fmt + '\n'
+
+    # configure logger
+    from hiddifypanel.models import ConfigEnum, hconfig
+    logger.remove()
+    logger.add(sys.stderr, format=dynamic_formatter, level=hconfig(ConfigEnum.log_level), colorize=True, catch=True, enqueue=True, diagnose=False, backtrace=True)
+    # logger.trace('Logger initiated :)')
+
+
+# TODO: refactor this function
+
 def create_app(*args, cli=False, **config):
 
     app = APIFlask(__name__, static_url_path="/<proxy_path>/static/", instance_relative_config=True, version='2.0.0', title="Hiddify API",
@@ -75,14 +91,7 @@ def create_app(*args, cli=False, **config):
     with app.app_context():
         init_db()
 
-        # configure logger
-        from hiddifypanel.models import ConfigEnum, hconfig
-        logger.remove()
-        log_format = '<green>{time:YYYY-MM-DD HH:mm:ss}</green> | <level>{level: <8}</level> | <cyan>{name}</cyan>:<cyan>{function}</cyan>:<cyan>{line}</cyan> - <level>{message}</level> | <level>{extra}</level>'
-        logger.add(sys.stderr, format=log_format, level=hconfig(ConfigEnum.log_level), colorize=True, catch=True, enqueue=True, diagnose=False, backtrace=True)
-
-    # flaskbabel = FlaskBabel(app)
-    # @babel.localeselector
+        init_logger()
 
     def get_locale():
         # Put your logic here. Application can store locale in

hiddifypanel/cache.py

@@ -1,5 +1,4 @@
-from redis_cache import RedisCache, CacheDecorator, compact_dump, chunks
-from redis_cache import loads as redis_cache_loads
+from redis_cache import RedisCache, chunks
 import redis
 from pickle import dumps, loads
 from loguru import logger
@@ -23,52 +22,4 @@ class CustomRedisCache(RedisCache):
             return False
 
 
-cache = CustomRedisCache(redis_client=redis_client, prefix="h", serializer=dumps, deserializer=loads)
-
-
-# cache = RedisCache(redis_client=redis_client, exception_handler=exception_handler)
-# cache = RedisCache(redis_client=redis_client, prefix="h", serializer=dumps, deserializer=loads, exception_handler=exception_handler)
-
-# def exception_handler(e, original_fn, args, kwargs):
-#     print("cache exception occur", e, original_fn, args, kwargs)
-#     return original_fn(*args, **kwargs)
-#     pass
-
-# class CacheDecorator:
-#     def __init__(self, *args, **kwargs):
-#         pass
-
-#     def __call__(self, fn):
-#         @wraps(fn)
-#         def inner(*args, **kwargs):
-
-#             parsed_result = fn(*args, **kwargs)
-
-#             return parsed_result
-
-#         inner.invalidate = self.invalidate
-#         inner.invalidate_all = self.invalidate_all
-#         inner.instance = self
-#         return inner
-
-#     def invalidate(self, *args, **kwargs):
-#         pass
-
-#     def invalidate_all(self, *args, **kwargs):
-#         pass
-
-
-# class DisableCache:
-#     cache = CacheDecorator
-
-
-# cache = DisableCache()
-# try:
-#     @cache.cache()
-#     def test():
-#         return 1
-#     test()
-# except Exception as e:
-#     import sys
-#     print('Caching Error! Disabling cache', e, file=sys.stderr)
-#     # cache = DisableCache()
+cache = CustomRedisCache(redis_client=redis_client, prefix="h", serializer=dumps, deserializer=loads)

hiddifypanel/drivers/wireguard_api.py

@@ -9,15 +9,35 @@ from hiddifypanel.panel.run_commander import Command, commander
 class WireguardApi(DriverABS):
     def is_enabled(self) -> bool:
         return hconfig(ConfigEnum.wireguard_enable)
-    WG_LOCAL_USAGE_FILE_PATH = './hiddify_usages.json'
+    
+    WG_LOCAL_USAGE_FILE_PATH = os.path.join('/opt/hiddify-manager/','hiddify-panel','wireguard_usages.json')
+    OLD_WG_LOCAL_USAGE_FILE_PATH = os.path.join('/opt/hiddify-manager/','hiddify-panel','hiddify_usages.json')
 
     def __init__(self) -> None:
         super().__init__()
+
+        if os.path.isfile(WireguardApi.OLD_WG_LOCAL_USAGE_FILE_PATH) and not os.path.isfile(WireguardApi.WG_LOCAL_USAGE_FILE_PATH):
+            os.rename(WireguardApi.OLD_WG_LOCAL_USAGE_FILE_PATH,WireguardApi.WG_LOCAL_USAGE_FILE_PATH)
+
+        if not self.is_usages_file_exists_and_json():
+            self.init_empty_usages_file()
         # create empty local usage file
-        if not os.path.isfile(WireguardApi.WG_LOCAL_USAGE_FILE_PATH):
-            with open(WireguardApi.WG_LOCAL_USAGE_FILE_PATH, 'w+') as f:
-                json.dump({}, f)
 
+    def is_usages_file_exists_and_json(self) -> bool:
+        if os.path.isfile(WireguardApi.WG_LOCAL_USAGE_FILE_PATH):
+            try:
+                # try to load it as a JSON
+                self.__get_local_usage()
+                return True
+            except json.decoder.JSONDecodeError:
+                os.remove(WireguardApi.WG_LOCAL_USAGE_FILE_PATH)
+                return False
+        return False
+    def init_empty_usages_file(self):
+        with open(WireguardApi.WG_LOCAL_USAGE_FILE_PATH, 'w+') as f:
+            json.dump({}, f)
+
+    
     def __get_wg_usages(self) -> dict:
         raw_output = commander(Command.update_wg_usage, run_in_background=False)
         data = {}
@@ -34,7 +54,6 @@ class WireguardApi(DriverABS):
         return data
 
     def __get_local_usage(self) -> dict:
-
         with open(WireguardApi.WG_LOCAL_USAGE_FILE_PATH, 'r') as f:
             data = json.load(f)
             return data

hiddifypanel/hutils/convert.py

@@ -57,7 +57,7 @@ def json_to_time(time_str: str) -> datetime | str:
     try:
         return datetime.strptime(__fix_time_format(time_str), "%Y-%m-%d %H:%M:%S")
     except BaseException:
-        return time_str
+        return json_to_date(time_str)
 
 
 def format_timedelta(delta: timedelta, add_direction: bool = True, granularity: str = "days") -> str:

hiddifypanel/hutils/flask.py

@@ -5,7 +5,7 @@ from apiflask import abort as apiflask_abort
 from flask_babel import gettext as _
 from flask import url_for  # type: ignore
 from urllib.parse import urlparse
-from markupsafe import Markup
+from strenum import StrEnum
 
 import user_agents
 import re
@@ -17,7 +17,7 @@ from hiddifypanel import hutils
 
 
 def flash(message: str, category: str = "message"):
-    if not isinstance(message,str):
+    if not isinstance(message, str):
         message = str(message)
     return flask_flash(message, category)
 
@@ -82,6 +82,8 @@ def __parse_user_agent(ua: str) -> dict:
     res['is_shadowrocket'] = re.match('^(Shadowrocket)', ua, re.IGNORECASE) and True
     res['is_v2rayng'] = re.match('^(v2rayNG)', ua, re.IGNORECASE) and True
 
+    if res['is_v2rayng']:
+        res['v2rayng_version'] = generic_version
     if res['is_singbox']:
         res['singbox_version'] = generic_version
 
@@ -254,6 +256,30 @@ def extract_parent_info_from_url(url) -> Tuple[str | None, str | None, str | Non
         return domain, proxy_path, admin_uuid
     else:
         return None, None, None
+
+
+class ClientVersion(StrEnum):
+    v2ryang = 'v2rayng_version'
+    hiddify_next = 'hiddify_version'
+
+
+def is_client_version(client: ClientVersion, major_v: int = 0, minor_v: int = 0, patch_v: int = 0) -> bool:
+    '''If the user agent version be equals or higher than parameters returns True'''
+    if raw_v := g.user_agent.get(client):
+        # TODO: probably we don't need these checks and the compare_versions can handle it (need to be test)
+        raw_v_len = len(raw_v)
+        u_major_v = raw_v[0] if raw_v_len > 0 else 0
+        u_minor_v = raw_v[1] if raw_v_len > 1 else 0
+        u_patch_v = raw_v[2] if raw_v_len > 2 else 0
+
+        user_agent_v = f'{u_major_v}.{u_minor_v}.{u_patch_v}'
+        needed_version = f'{major_v}.{minor_v}.{patch_v}'
+
+        res = hutils.utils.compare_versions(user_agent_v, needed_version)
+        if res == 0 or res == 1:
+            return True
+    return False
+
 # region not used
 
 

hiddifypanel/hutils/importer/xui.py

@@ -1,14 +1,14 @@
 import sqlite3
 import json
-from typing import Any, Dict, List, Tuple
+import os
 import uuid as uuid_mod
+from typing import Any, Dict, List, Tuple
 from datetime import datetime
 from dateutil.relativedelta import relativedelta
+
 from hiddifypanel import hutils
 from hiddifypanel.models import *
 from hiddifypanel.database import db, db_execute
-import os
-from sqlalchemy import text
 
 
 def __query_fetch_json(db, query: str, **kwargs) -> List[Dict[str, Any]]:
@@ -65,9 +65,9 @@ def __create_hiddify_user_from_xui_values(id: str, values: Dict[str, Any]) -> "U
     user.uuid = id if hutils.auth.is_uuid_valid(id, 4) else uuid_mod.uuid4()
 
     if str(values['expiry_time']) == '0':
-        user.expiry_time = datetime.now() + relativedelta(years=10)
+        user.package_days = 3650
     else:
-        user.expiry_time = datetime.fromtimestamp(values['expiry_time'] / 1000)
+        user.package_days = max(0, (datetime.fromtimestamp(values['expiry_time'] / 1000) - datetime.today()).days)
 
     user.usage_limit = values['max_usage_bytes']
     user.current_usage = values['current_usage_bytes']
@@ -145,8 +145,7 @@ def import_data(db_path: str):
             User.add_or_update(commit=False, **u)
 
         for d in hiddify_domains_dict:
-            from hiddifypanel.panel import hiddify
-            hiddify.add_or_update_domain(commit=False, **d)
+            Domain.add_or_update(commit=False, **d)
 
         db.session.commit()  # type: ignore
     except Exception as err:

hiddifypanel/hutils/network/__init__.py

@@ -2,3 +2,4 @@
 from . import auto_ip_selector
 # from .ip import get_domain_ip, get_socket_public_ip, get_interface_public_ip, get_ips, get_ip
 from .net import *
+from . import cf_api

hiddifypanel/hutils/network/cf_api.py

@@ -0,0 +1,84 @@
+import CloudFlare
+from hiddifypanel.models import hconfig, ConfigEnum
+
+__cf: CloudFlare.CloudFlare = ''  # type: ignore
+
+
+def __prepare_cf_api_client() -> bool:
+    '''Prepares cloudflare client if it's not already'''
+    global __cf
+    if __cf and isinstance(__cf, CloudFlare.CloudFlare):
+        return True
+
+    if hconfig(ConfigEnum.cloudflare):
+        __cf = CloudFlare.CloudFlare(token=hconfig(ConfigEnum.cloudflare))
+        if __cf and isinstance(__cf, CloudFlare.CloudFlare):
+            return True
+    return False
+
+
+def add_or_update_dns_record(domain: str, ip: str, dns_type: str = "A", proxied: bool = True) -> bool:
+    '''This function cloud throw an exception'''
+    if not __prepare_cf_api_client():
+        return False
+
+    zone_name = __extract_root_domain(domain)
+    zone = __get_zone(zone_name)
+    if zone:
+        record = __get_dns_record(zone, domain)
+        dns_name = domain[:-len(zone['name'])].replace('.', '')
+        # if the input domain is root itself
+        dns_name = '@' if not dns_name else dns_name
+        data = {
+            'name': dns_name,
+            'type': dns_type, 'content': ip, 'proxied': proxied
+        }
+        if not record:
+            api_res = __cf.zones.dns_records.post(zone['id'], data=data)
+        else:
+            api_res = __cf.zones.dns_records.put(zone['id'], record['id'], data=data)
+
+        # validate api response
+        if api_res['name'] == domain and api_res['type'] == dns_type and api_res['content'] == ip:
+            return True
+    return False
+
+
+def delete_dns_record(domain: str) -> bool:
+    '''Deletes a DNS record from cloudflare panel of user'''
+    if not __prepare_cf_api_client():
+        return False
+
+    zone_name = __extract_root_domain(domain)
+    zone = __get_zone(zone_name)
+    record = __get_dns_record(zone, domain)
+    if zone and record:
+        api_res = __cf.zones.dns_records.delete(zone['id'], record['id'])
+        if api_res['id'] == record['id']:
+            return True
+    return False
+
+
+def __get_zone(zone_name: str) -> dict | None:
+    zones = __cf.zones.get()
+    for z in zones:
+        if z['name'] == zone_name:
+            return z
+    return None
+
+
+def __get_dns_record(zone, domain: str) -> dict | None:
+    '''Returns dns record if exists'''
+    dns_records = __cf.zones.dns_records(zone['id'])
+    for r in dns_records:
+        if r['name'] == domain:
+            return r
+    return None
+
+
+def __extract_root_domain(domain: str) -> str:
+    domain_parts = domain.split(".")
+    if len(domain_parts) > 1:
+        return ".".join(domain_parts[-2:])
+    else:
+        return domain

hiddifypanel/hutils/network/net.py

@@ -1,4 +1,4 @@
-from typing import List, Literal, Tuple, Union
+from typing import List, Literal, Union
 from urllib.parse import urlparse
 import urllib.request
 import ipaddress
@@ -136,46 +136,6 @@ def get_ip(version: Literal[4, 6], retry: int = 5) -> ipaddress.IPv4Address | ip
         ip = get_ip(version, retry=retry - 1)
     return ip
 
-
-def check_connection_to_remote(api_url: str) -> bool:
-
-    path = f"{api_url}/api/v1/hello/"
-
-    try:
-        _ = requests.get(path, verify=False, timeout=2).json()
-        return True
-
-    except BaseException:
-        return False
-
-
-def check_connection_for_domain(domain: str) -> bool:
-
-    proxy_path = hconfig(ConfigEnum.proxy_path_admin)
-    admin_secret = hconfig(ConfigEnum.admin_secret)
-    path = f"{proxy_path}/{admin_secret}/api/v1/hello/"
-    try:
-        print(f"https://{domain}/{path}")
-        res = requests.get(
-            f"https://{domain}/{path}", verify=False, timeout=10).json()
-        return res['status'] == 200
-
-    except BaseException:
-        try:
-            print(f"http://{domain}/{path}")
-            res = requests.get(
-                f"http://{domain}/{path}", verify=False, timeout=10).json()
-            return res['status'] == 200
-        except BaseException:
-            try:
-                print(f"http://{get_domain_ip(domain)}/{path}")
-                res = requests.get(
-                    f"http://{get_domain_ip(domain)}/{path}", verify=False, timeout=10).json()
-                return res['status'] == 200
-            except BaseException:
-                return False
-
-
 def get_random_domains(count: int = 1, retry: int = 3) -> List[str]:
     try:
         irurl = "https://api.ooni.io/api/v1/measurements?probe_cc=IR&test_name=web_connectivity&anomaly=false&confirmed=false&failure=false&order_by=test_start_time&limit=1000"
@@ -205,7 +165,7 @@ def is_domain_support_tls_13(domain: str) -> bool:
             return ssock.version() == "TLSv1.3"
 
 
-def is_domain_support_h2(sni: str, server: str = '') -> bool:
+def is_domain_support_h2_tls13(sni: str, server: str = '') -> bool:
     try:
 
         context = ssl.create_default_context(purpose=ssl.Purpose.SERVER_AUTH)
@@ -229,11 +189,11 @@ def is_domain_support_h2(sni: str, server: str = '') -> bool:
 
 
 def is_domain_reality_friendly(domain: str) -> bool:
-    return is_domain_support_h2(domain)
+    return is_domain_support_h2_tls13(domain)
 
 
 def fallback_domain_compatible_with_servernames(fallback_domain: str, servername: str) -> bool:
-    return is_domain_support_h2(servername, fallback_domain)
+    return is_domain_support_h2_tls13(servername, fallback_domain)
 
 
 def get_random_decoy_domain() -> str:
@@ -329,10 +289,9 @@ def add_number_to_ipv6(ip: str, number: int) -> str:
     return modified_ipv6
 
 
+@cache.cache(600)
 def is_in_same_asn(domain_or_ip: str, domain_or_ip_target: str) -> bool:
     '''Returns True if domain is in panel ASN'''
-    if not IPASN:
-        return False
     try:
         ip = domain_or_ip if is_ip(domain_or_ip) else get_domain_ip(domain_or_ip)
         ip_target = domain_or_ip_target if is_ip(domain_or_ip_target) else get_domain_ip(domain_or_ip_target)
@@ -340,8 +299,8 @@ def is_in_same_asn(domain_or_ip: str, domain_or_ip_target: str) -> bool:
         if not ip or not ip_target:
             return False
 
-        ip_asn = get_ip_asn_name(ip)
-        ip_target_asn = get_ip_asn_name(ip_target)
+        ip_asn = get_ip_asn(ip)
+        ip_target_asn = get_ip_asn(ip_target)
 
         if not ip_asn or not ip_target_asn:
             return False
@@ -355,7 +314,10 @@ def is_in_same_asn(domain_or_ip: str, domain_or_ip_target: str) -> bool:
         #                    f"<br> Server ASN={asn_ipv4.get('autonomous_system_organization','unknown')}<br>{domain}_ASN={asn_dip.get('autonomous_system_organization','unknown')}", "warning")
 
 
-def get_ip_asn_name(ip: ipaddress.IPv4Address | ipaddress.IPv6Address | str) -> str:
+@cache.cache(600)
+def get_ip_asn(ip: ipaddress.IPv4Address | ipaddress.IPv6Address | str) -> str:
+    if not IPASN:
+        return __get_ip_asn_api(ip)
     try:
         if asn := IPASN.get(str(ip)):
             return str(asn.get('autonomous_system_organization', ''))
@@ -364,9 +326,24 @@ def get_ip_asn_name(ip: ipaddress.IPv4Address | ipaddress.IPv6Address | str) ->
         return ''
 
 
+def __get_ip_asn_api(ip: ipaddress.IPv4Address | ipaddress.IPv6Address | str) -> str:
+    ip = str(ip)
+    if not is_ip(ip):
+        return ''
+    endpoint = f'https://ipapi.co/{ip}/asn/'
+    return str(requests.get(endpoint).content)
+
+
+@cache.cache(3600)
 def is_ip(input: str):
     try:
         _ = ipaddress.ip_address(input)
         return True
     except:
         return False
+
+def resolve_domain_with_api(domain:str) -> str:
+    if not domain:
+        return ''
+    endpoint = f'http://ip-api.com/json/{domain}?fields=query'
+    return str(requests.get(endpoint).json().get('query'))

hiddifypanel/hutils/node/child.py

@@ -1,7 +1,9 @@
 from loguru import logger
 import socket
+from flask_babel import gettext as _
+from strenum import StrEnum
 
-from hiddifypanel.models import AdminUser, User, hconfig, ConfigEnum, ChildMode, set_hconfig, Domain, Proxy, StrConfig, BoolConfig, Child, ChildMode
+from hiddifypanel.models import AdminUser, User, hconfig, ConfigEnum, ChildMode, Domain, Proxy, StrConfig, BoolConfig, Child, ChildMode
 from hiddifypanel import hutils
 from hiddifypanel.panel import hiddify
 from hiddifypanel.panel import usage
@@ -34,11 +36,27 @@ def __get_register_data_for_api(name: str, mode: ChildMode) -> RegisterInputSche
     return register_data
 
 
-def __get_sync_data_for_api() -> SyncInputSchema:
+class SyncFields(StrEnum):
+    domains = 'domains'
+    proxies = 'proxies'
+    hconfigs = 'hconfigs'
+
+
+def __get_sync_data_for_api(*fields: SyncFields) -> SyncInputSchema:
     sync_data = SyncInputSchema()
-    sync_data.domains = [domain.to_schema() for domain in Domain.query.all()]  # type: ignore
-    sync_data.proxies = [proxy.to_schema() for proxy in Proxy.query.all()]  # type: ignore
-    sync_data.hconfigs = [*[u.to_schema() for u in StrConfig.query.all()], *[u.to_schema() for u in BoolConfig.query.all()]]  # type: ignore
+    if len(fields) == 0:
+        sync_data.domains = [domain.to_schema() for domain in Domain.query.all()]  # type: ignore
+        sync_data.proxies = [proxy.to_schema() for proxy in Proxy.query.all()]  # type: ignore
+        sync_data.hconfigs = [*[u.to_schema() for u in StrConfig.query.all()], *[u.to_schema() for u in BoolConfig.query.all()]]  # type: ignore
+    else:
+        for f in fields:
+            match f:
+                case SyncFields.domains:
+                    sync_data.domains = [domain.to_schema() for domain in Domain.query.all()]  # type: ignore
+                case SyncFields.proxies:
+                    sync_data.proxies = [proxy.to_schema() for proxy in Proxy.query.all()]  # type: ignore
+                case SyncFields.hconfigs:
+                    sync_data.hconfigs = [*[u.to_schema() for u in StrConfig.query.all()], *[u.to_schema() for u in BoolConfig.query.all()]]  # type: ignore
 
     return sync_data
 
@@ -103,7 +121,7 @@ def register_to_parent(name: str, apikey: str, mode: ChildMode = ChildMode.remot
     return True
 
 
-def sync_with_parent() -> bool:
+def sync_with_parent(*fields: SyncFields) -> bool:
     # sync usage first
     if not sync_users_usage_with_parent():
         logger.error("Error while syncing with parent: Failed to sync users usage")
@@ -113,7 +131,7 @@ def sync_with_parent() -> bool:
     if not p_url:
         logger.error("Error while syncing with parent: Parent url is empty")
         return False
-    payload = __get_sync_data_for_api()
+    payload = __get_sync_data_for_api(*fields)
     res = NodeApiClient(p_url).put('/api/v2/parent/sync/', payload, SyncOutputSchema)
     if isinstance(res, NodeApiErrorSchema):
         logger.error(f"Error while syncing with parent: {res.msg}")

hiddifypanel/hutils/node/parent.py

@@ -3,7 +3,7 @@ from flask_babel import lazy_gettext as _
 from typing import List
 from loguru import logger
 
-from hiddifypanel.models import Child, AdminUser, ConfigEnum, Domain, ChildMode, hconfig, get_panel_link
+from hiddifypanel.models import Child, AdminUser, ConfigEnum, Domain, hconfig, Domain
 from hiddifypanel import hutils
 from hiddifypanel.panel.commercial.restapi.v2.child.schema import RegisterWithParentInputSchema
 from .api_client import NodeApiClient, NodeApiErrorSchema
@@ -15,12 +15,12 @@ def request_childs_to_sync():
     for c in Child.query.filter(Child.id != 0).all():
         if not request_child_to_sync(c):
             logger.error(f'{c.name}: {_("parent.sync-req-failed")}')
-            hutils.flask.flash(f'{c.name}: ' + _('parent.sync-req-failed'), 'danger')
+            hutils.flask.flash(f'{c.name}: ' + _('parent.sync-req-failed'), 'danger') # just for debug
 
 
 def request_child_to_sync(child: Child) -> bool:
     '''Requests to a child to sync itself with the current panel'''
-    child_domain = get_panel_link(child.id)
+    child_domain = Domain.get_panel_link(child.id)  # type:ignore
     if not child_domain:
         logger.error(f"Child {child.name} has no valid domain")
         return False
@@ -49,14 +49,14 @@ def request_chlid_to_register(name: str, child_link: str, apikey: str) -> bool:
     if not child_link or not apikey:
         logger.error("Child link or apikey is empty")
         return False
-    domain = get_panel_link()
+    domain = Domain.get_panel_link()
     if not domain:
         logger.error("Domain is empty")
         return False
     from hiddifypanel.panel import hiddify
 
     payload = RegisterWithParentInputSchema()
-    payload.parent_panel = hiddify.get_account_panel_link(AdminUser.by_uuid(g.account.uuid), domain.domain)  # type: ignore
+    payload.parent_panel = hiddify.get_account_panel_link(AdminUser.by_uuid(g.account.uuid), domain)  # type: ignore
     payload.apikey = payload.name = hconfig(ConfigEnum.unique_id)
 
     logger.debug(f"Requesting child {name} to register")
@@ -87,14 +87,14 @@ def is_child_domain_active(child: Child, domain: Domain) -> bool:
 
 def get_child_active_domains(child: Child) -> List[Domain]:
     actives = []
-    for d in child.domains:
+    for d in child.domains:  # type: ignore
         if is_child_domain_active(child, d):
             actives.append(d)
     return actives
 
 
 def is_child_active(child: Child) -> bool:
-    for d in child.domains:
+    for d in child.domains:  # type: ignore
         if is_child_domain_active(child, d):
             return True
     return False

hiddifypanel/hutils/node/shared.py

@@ -1,4 +1,7 @@
+import threading
 from loguru import logger
+from typing import Callable
+from flask import copy_current_request_context
 
 from hiddifypanel.models import hconfig, ConfigEnum, PanelMode, User
 from hiddifypanel.cache import cache
@@ -40,11 +43,13 @@ def convert_usage_api_response_to_dict(data: dict) -> dict:
 
 # endregion
 
+# TODO: use cache for these functions in release
+# @cache.cache(ttl=150)
 
-#@cache.cache(ttl=150)
-def is_panel_active(domain: str, proxy_path: str,apikey:str|None = None) -> bool:
+
+def is_panel_active(domain: str, proxy_path: str, apikey: str | None = None) -> bool:
     base_url = f'https://{domain}/{proxy_path}'
-    res = NodeApiClient(base_url,apikey).get('/api/v2/panel/ping/', dict)
+    res = NodeApiClient(base_url, apikey).get('/api/v2/panel/ping/', dict)
     if isinstance(res, NodeApiErrorSchema):
         logger.error(f"Error while checking if panel is active: {res.msg}")
         return False
@@ -55,11 +60,19 @@ def is_panel_active(domain: str, proxy_path: str,apikey:str|None = None) -> bool
     return False
 
 
-#@cache.cache(300)
-def get_panel_info(domain: str, proxy_path: str,apikey:str|None = None) -> dict | None:
+# @cache.cache(300)
+def get_panel_info(domain: str, proxy_path: str, apikey: str | None = None) -> dict | None:
     base_url = f'https://{domain}/{proxy_path}'
-    res = NodeApiClient(base_url,apikey).get('/api/v2/panel/info/', PanelInfoOutputSchema)
+    res = NodeApiClient(base_url, apikey).get('/api/v2/panel/info/', PanelInfoOutputSchema)
     if isinstance(res, NodeApiErrorSchema):
         logger.error(f"Error while getting panel info from {domain}: {res.msg}")
         return None
     return res
+
+
+def run_node_op_in_bg(op: Callable, *args, **kwargs):
+    @copy_current_request_context
+    def wrapped_op():
+        op(*args, **kwargs)
+
+    threading.Thread(target=wrapped_op).start()

hiddifypanel/hutils/proxy/clash.py

@@ -1,5 +1,5 @@
 import yaml
-from hiddifypanel.models import Proxy, ProxyCDN, ProxyL3, ProxyProto, ProxyTransport, Domain
+from hiddifypanel.models import ProxyCDN, ProxyL3, ProxyProto, ProxyTransport, Domain
 from hiddifypanel import hutils
 
 

hiddifypanel/hutils/proxy/shared.py

@@ -293,7 +293,7 @@ def make_proxy(hconfigs: dict, proxy: Proxy, domain_db: Domain, phttp=80, ptls=4
         return base
 
     if proxy.proto in [ProxyProto.vmess]:
-        base['cipher'] = "chacha20-poly1305"
+        base['cipher'] = "auto"  # "chacha20-poly1305"
 
     if l3 in ['reality']:
         base['reality_short_id'] = random.sample(hconfigs[ConfigEnum.reality_short_ids].split(','), 1)[0]