hiddifypanel 10.14.0__py3-none-any.whl → 10.15.0.dev0__py3-none-any.whl

hiddifypanel/hutils/node/parent.py

@@ -0,0 +1,100 @@
+from flask import g
+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 import hutils
+from hiddifypanel.panel.commercial.restapi.v2.child.schema import RegisterWithParentInputSchema
+from .api_client import NodeApiClient, NodeApiErrorSchema
+
+from hiddifypanel.cache import cache
+
+
+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')
+
+
+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)
+    if not child_domain:
+        logger.error(f"Child {child.name} has no valid domain")
+        return False
+
+    child_admin_proxy_path = hconfig(ConfigEnum.proxy_path_admin, child.id)
+    base_url = f'https://{child_domain}/{child_admin_proxy_path}'
+    path = '/api/v2/child/sync-parent/'
+    res = NodeApiClient(base_url).post(path, payload=None, output=dict)
+    if isinstance(res, NodeApiErrorSchema):
+        logger.error(f"Error while requesting child {child.name} to sync: {res.msg}")
+        return False
+    if res['msg'] == 'ok':
+        logger.success(f"Successfully requested child {child.name} to sync")
+        cache.invalidate_all_cached_functions()
+        return True
+
+    logger.error(f"Request to child {child.name} to sync failed")
+    return False
+
+# before using this function should check child version
+
+
+# TODO: not used
+def request_chlid_to_register(name: str, child_link: str, apikey: str) -> bool:
+    '''Requests to a child to register itself with the current panel'''
+    if not child_link or not apikey:
+        logger.error("Child link or apikey is empty")
+        return False
+    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.apikey = payload.name = hconfig(ConfigEnum.unique_id)
+
+    logger.debug(f"Requesting child {name} to register")
+    res = NodeApiClient(child_link, apikey).post('/api/v2/child/register-parent/', payload, dict)
+    if isinstance(res, NodeApiErrorSchema):
+        logger.error(f"Error while requesting child {name} to register: {res.msg}")
+        return False
+
+    if res['msg'] == 'ok':
+        logger.success(f"Successfully requested child {name} to register")
+        cache.invalidate_all_cached_functions()
+        return True
+
+    logger.error(f"Request to child {name} to register failed")
+    return False
+
+
+def is_child_domain_active(child: Child, domain: Domain) -> bool:
+    '''Checks whether a child's domain is responsive'''
+    if not domain.need_valid_ssl:
+        return False
+    child_admin_proxy_path = hconfig(ConfigEnum.proxy_path_admin, child.id)
+    if not child_admin_proxy_path:
+        return False
+
+    return hutils.node.is_panel_active(domain.domain, child_admin_proxy_path)
+
+
+def get_child_active_domains(child: Child) -> List[Domain]:
+    actives = []
+    for d in child.domains:
+        if is_child_domain_active(child, d):
+            actives.append(d)
+    return actives
+
+
+def is_child_active(child: Child) -> bool:
+    for d in child.domains:
+        if is_child_domain_active(child, d):
+            return True
+    return False

hiddifypanel/hutils/node/shared.py

@@ -0,0 +1,65 @@
+from loguru import logger
+
+from hiddifypanel.models import hconfig, ConfigEnum, PanelMode, User
+from hiddifypanel.cache import cache
+from hiddifypanel.panel.commercial.restapi.v2.parent.schema import UsageInputOutputSchema, UsageData
+from hiddifypanel.panel.commercial.restapi.v2.panel.schema import PanelInfoOutputSchema
+from .api_client import NodeApiClient, NodeApiErrorSchema
+
+
+def is_child() -> bool:
+    return hconfig(ConfigEnum.panel_mode) == PanelMode.child
+
+
+def is_parent() -> bool:
+    return hconfig(ConfigEnum.panel_mode) == PanelMode.parent
+
+# region usage
+
+
+def get_users_usage_data_for_api() -> UsageInputOutputSchema:
+    res = UsageInputOutputSchema()
+    res.usages = []  # type: ignore
+    for u in User.query.all():
+        usage_data = UsageData()
+        usage_data.uuid = u.uuid
+        usage_data.usage = u.current_usage
+        usage_data.devices = u.devices
+        res.usages.append(usage_data)  # type: ignore
+    return res
+
+
+def convert_usage_api_response_to_dict(data: dict) -> dict:
+    converted = {}
+    for i in data['usages']:  # type: ignore
+        converted[str(i['uuid'])] = {
+            'usage': i['usage'],
+            'devices': ','.join(i['devices'])  # type: ignore
+        }
+    return converted
+
+# endregion
+
+
+#@cache.cache(ttl=150)
+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)
+    if isinstance(res, NodeApiErrorSchema):
+        logger.error(f"Error while checking if panel is active: {res.msg}")
+        return False
+    if 'PONG' in res['msg']:
+        logger.debug(f"Panel is active: {res['msg']}")
+        return True
+    logger.debug("Panel is not active")
+    return False
+
+
+#@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)
+    if isinstance(res, NodeApiErrorSchema):
+        logger.error(f"Error while getting panel info from {domain}: {res.msg}")
+        return None
+    return res

hiddifypanel/hutils/proxy/shared.py

@@ -5,7 +5,7 @@ import re
 import json
 from ipaddress import IPv4Address, IPv6Address
 from hiddifypanel.cache import cache
-from hiddifypanel.models import Proxy, ProxyProto, ProxyTransport, ProxyCDN, Domain, DomainType, ConfigEnum, hconfig, get_hconfigs
+from hiddifypanel.models import Proxy, ProxyProto, ProxyL3, ProxyTransport, ProxyCDN, Domain, DomainType, ConfigEnum, hconfig, get_hconfigs
 from hiddifypanel import hutils
 
 
@@ -124,16 +124,28 @@ def get_proxies(child_id: int = 0, only_enabled=False) -> list['Proxy']:
         proxies = [c for c in proxies if 'ssr' != c.proto]
     if not hconfig(ConfigEnum.vmess_enable, child_id):
         proxies = [c for c in proxies if 'vmess' not in c.proto]
+    if not hconfig(ConfigEnum.vless_enable, child_id):
+        proxies = [c for c in proxies if 'vless' not in c.proto]
+    if not hconfig(ConfigEnum.trojan_enable, child_id):
+        proxies = [c for c in proxies if 'trojan' not in c.proto]
     if not hconfig(ConfigEnum.httpupgrade_enable, child_id):
         proxies = [c for c in proxies if ProxyTransport.httpupgrade not in c.transport]
     if not hconfig(ConfigEnum.ws_enable, child_id):
         proxies = [c for c in proxies if ProxyTransport.WS not in c.transport]
-
+    if not hconfig(ConfigEnum.xtls_enable, child_id):
+        proxies = [c for c in proxies if ProxyTransport.XTLS not in c.transport]
     if not hconfig(ConfigEnum.grpc_enable, child_id):
         proxies = [c for c in proxies if ProxyTransport.grpc not in c.transport]
+    if not hconfig(ConfigEnum.tcp_enable, child_id):
+        proxies = [c for c in proxies if 'tcp' not in c.transport]
+    if not hconfig(ConfigEnum.h2_enable, child_id):
+        proxies = [c for c in proxies if 'h2' not in c.transport and c.l3 not in [ProxyL3.tls_h2_h1, ProxyL3.tls_h2]]
     if not hconfig(ConfigEnum.kcp_enable, child_id):
         proxies = [c for c in proxies if 'kcp' not in c.l3]
-
+    if not hconfig(ConfigEnum.reality_enable, child_id):
+        proxies = [c for c in proxies if 'reality' not in c.l3]
+    if not hconfig(ConfigEnum.quic_enable, child_id):
+        proxies = [c for c in proxies if 'h3_quic' not in c.l3]
     if not hconfig(ConfigEnum.http_proxy_enable, child_id):
         proxies = [c for c in proxies if 'http' != c.l3]
 

hiddifypanel/models/__init__.py

@@ -1,10 +1,10 @@
 from .role import Role, AccountType
 from .child import Child, ChildMode
-from .config_enum import ConfigCategory, ConfigEnum, Lang, ApplyMode
+from .config_enum import ConfigCategory, ConfigEnum, Lang, ApplyMode, PanelMode, LogLevel
 from .config import StrConfig, BoolConfig, get_hconfigs, hconfig, set_hconfig, add_or_update_config, bulk_register_configs, get_hconfigs_childs
 
 # from .parent_domain import ParentDomain
-from .domain import Domain, DomainType, ShowDomain, get_domain, get_current_proxy_domains, get_panel_domains, get_proxy_domains, get_proxy_domains_db, get_hdomains, hdomain, add_or_update_domain, bulk_register_domains
+from .domain import Domain, DomainType, ShowDomain, get_domain, get_current_proxy_domains, get_panel_domains, get_proxy_domains, get_proxy_domains_db, get_hdomains, hdomain, add_or_update_domain, bulk_register_domains, get_panel_link
 from .proxy import Proxy, ProxyL3, ProxyCDN, ProxyProto, ProxyTransport
 from .user import User, UserMode, UserDetail, ONE_GIG
 from .admin import AdminUser, AdminMode

hiddifypanel/models/admin.py

@@ -7,7 +7,7 @@ from strenum import StrEnum
 from apiflask import abort
 from flask_babel import gettext as __
 from flask_babel import lazy_gettext as _
-from hiddifypanel.database import db
+from hiddifypanel.database import db, db_execute
 from hiddifypanel.models.role import Role
 from hiddifypanel.models.base_account import BaseAccount
 
@@ -50,6 +50,15 @@ class AdminUser(BaseAccount):
                 return Role.agent
         return None
 
+    @staticmethod
+    def form_schema(schema):
+        return schema.dump(AdminUser())
+
+    def to_schema(self):
+        admin_dict = self.to_dict()
+        from hiddifypanel.panel.commercial.restapi.v2.admin.admin_user_api import AdminSchema
+        return AdminSchema().load(admin_dict)
+
     def get_id(self) -> str | None:
         return f'admin_{self.id}'
 
@@ -57,10 +66,12 @@ class AdminUser(BaseAccount):
         base = super().to_dict()
         if dump_id:
             base['id'] = self.id
+        from hiddifypanel.models import hconfig, ConfigEnum
         return {**base,
                 'mode': self.mode,
                 'can_add_admin': self.can_add_admin,
                 'parent_admin_uuid': self.parent_admin.uuid if self.parent_admin else None,
+                'lang': hconfig(ConfigEnum.admin_lang)
                 }
 
     @classmethod
@@ -144,7 +155,8 @@ class AdminUser(BaseAccount):
         if not admin:
             db.session.add(AdminUser(id=1, uuid=str(uuid.uuid4()), name="Owner", mode=AdminMode.super_admin, comment=""))
             db.session.commit()
-            db.engine.execute("update admin_user set id=1 where name='Owner'")
+
+            db_execute("update admin_user set id=1 where name='Owner'")
             admin = AdminUser.by_id(1)
 
         return admin

hiddifypanel/models/base_account.py

@@ -2,13 +2,13 @@ import datetime
 import uuid
 from hiddifypanel.models.role import Role
 from sqlalchemy import Column, String, BigInteger, Enum
-from sqlalchemy_serializer import SerializerMixin
+
 from flask_login import UserMixin as FlaskLoginUserMixin
 from hiddifypanel.models import Lang
 from hiddifypanel.database import db
 
 
-class BaseAccount(db.Model, SerializerMixin, FlaskLoginUserMixin):  # type: ignore
+class BaseAccount(db.Model, FlaskLoginUserMixin):  # type: ignore
     __abstract__ = True
     uuid = Column(String(36), default=lambda: str(uuid.uuid4()), nullable=False, unique=True, index=True)
     name = Column(String(512), nullable=False, default='')
@@ -74,7 +74,7 @@ class BaseAccount(db.Model, SerializerMixin, FlaskLoginUserMixin):  # type: igno
         for u in accounts:
             cls.add_or_update(commit=False, **u)
         if remove:
-            dd = {u['uuid']: 1 for u in accounts}
+            dd = {str(u['uuid']): 1 for u in accounts}
             for d in cls.query.all():
                 if d.uuid not in dd:
                     db.session.delete(d)  # type: ignore

hiddifypanel/models/child.py

@@ -1,30 +1,34 @@
 from __future__ import annotations
 import uuid
-from sqlalchemy_serializer import SerializerMixin
+
+from sqlalchemy import Column, Integer, String, Enum, text
 from enum import auto
 from strenum import StrEnum
 from flask import g, has_app_context
 
 
-from hiddifypanel.database import db
+from hiddifypanel.database import db, db_execute
 
 
 class ChildMode(StrEnum):
     virtual = auto()
-    remote = auto()
+    remote = auto()  # it's child
+    parent = auto()
+
+# the child model is node
 
 
-class Child(db.Model, SerializerMixin):
-    id = db.Column(db.Integer, primary_key=True, autoincrement=True)
-    name = db.Column(db.String(200), nullable=False, unique=True)
-    mode = db.Column(db.Enum(ChildMode), nullable=False, default=ChildMode.virtual)
+class Child(db.Model):  # type: ignore
+    id = Column(Integer, primary_key=True, autoincrement=True)
+    name = Column(String(200), nullable=False, unique=False)
+    mode = Column(Enum(ChildMode), nullable=False, default=ChildMode.virtual)
     # ip = db.Column(db.String(200), nullable=False, unique=True)
-    unique_id = db.Column(db.String(200), nullable=False, default=lambda: str(uuid.uuid4()), unique=True)
-    domains = db.relationship('Domain', cascade="all,delete", backref='child')
-    proxies = db.relationship('Proxy', cascade="all,delete", backref='child')
-    boolconfigs = db.relationship('BoolConfig', cascade="all,delete", backref='child')
-    strconfigs = db.relationship('StrConfig', cascade="all,delete", backref='child')
-    dailyusages = db.relationship('DailyUsage', cascade="all,delete", backref='child')
+    unique_id = Column(String(200), nullable=False, default=lambda: str(uuid.uuid4()), unique=True)
+    domains = db.relationship('Domain', cascade="all,delete", backref='child')  # type: ignore
+    proxies = db.relationship('Proxy', cascade="all,delete", backref='child')  # type: ignore
+    boolconfigs = db.relationship('BoolConfig', cascade="all,delete", backref='child')  # type: ignore
+    strconfigs = db.relationship('StrConfig', cascade="all,delete", backref='child')  # type: ignore
+    dailyusages = db.relationship('DailyUsage', cascade="all,delete", backref='child')  # type: ignore
 
     def to_dict(self):
         return {
@@ -55,11 +59,14 @@ class Child(db.Model, SerializerMixin):
             db.session.commit()
 
     @classmethod
-    def by_id(cls, id: int) -> "Child":
+    def by_id(cls, id: int) -> 'Child':
         return Child.query.filter(Child.id == id).first()
 
     @classmethod
-    @property
+    def by_unique_id(cls, unique_id: str) -> 'Child':
+        return Child.query.filter(Child.unique_id == unique_id).first()
+
+    @classmethod
     def current(cls) -> "Child":
         if has_app_context() and hasattr(g, "child"):
             return g.child
@@ -68,6 +75,13 @@ class Child(db.Model, SerializerMixin):
             tmp_uuid = str(uuid.uuid4())
             db.session.add(Child(id=0, unique_id=tmp_uuid, name="Root"))
             db.session.commit()
-            db.engine.execute(f'update child set id=0 where unique_id="{tmp_uuid}"')
+            db_execute(f"update child set id=0 where unique_id='{tmp_uuid}'")
             child = Child.by_id(0)
+            print("child-=======", child)
         return child
+
+    @classmethod
+    @property
+    def node(cls) -> "Child | None":
+        if has_app_context() and hasattr(g, "node"):
+            return g.node

hiddifypanel/models/config.py

@@ -1,11 +1,13 @@
-from hiddifypanel.models.config_enum import ConfigEnum
+from typing import Optional
+from hiddifypanel.models.config_enum import ConfigEnum, LogLevel, PanelMode, Lang
 from flask import g
-from sqlalchemy_serializer import SerializerMixin
+
 from hiddifypanel import Events
 from hiddifypanel.database import db
 from hiddifypanel.cache import cache
 from hiddifypanel.models.child import Child, ChildMode
 from sqlalchemy import Column, String, Boolean, Enum, ForeignKey, Integer
+from strenum import StrEnum
 
 
 def error(st):
@@ -13,7 +15,7 @@ def error(st):
     err(st)
 
 
-class BoolConfig(db.Model, SerializerMixin):
+class BoolConfig(db.Model):
     child_id = Column(Integer, ForeignKey('child.id'), primary_key=True, default=0)
     # category = db.Column(db.String(128), primary_key=True)
     key = Column(Enum(ConfigEnum), primary_key=True)
@@ -26,8 +28,17 @@ class BoolConfig(db.Model, SerializerMixin):
             'child_unique_id': d.child.unique_id if d.child else ''
         }
 
+    @staticmethod
+    def from_schema(schema):
+        return schema.dump(BoolConfig())
+
+    def to_schema(self):
+        conf_dict = self.to_dict()
+        from hiddifypanel.panel.commercial.restapi.v2.parent.schema import HConfigSchema
+        return HConfigSchema().load(conf_dict)
 
-class StrConfig(db.Model, SerializerMixin):
+
+class StrConfig(db.Model):
     child_id = Column(Integer, ForeignKey('child.id'), primary_key=True, default=0)
     # category = db.Column(db.String(128), primary_key=True)
     key = Column(Enum(ConfigEnum), primary_key=True, default=ConfigEnum.admin_secret)
@@ -40,11 +51,20 @@ class StrConfig(db.Model, SerializerMixin):
             'child_unique_id': d.child.unique_id if d.child else ''
         }
 
+    @staticmethod
+    def from_schema(schema):
+        return schema.dump(StrConfig())
+
+    def to_schema(self):
+        conf_dict = self.to_dict()
+        from hiddifypanel.panel.commercial.restapi.v2.parent.schema import HConfigSchema
+        return HConfigSchema().load(conf_dict)
+
 
 @cache.cache(ttl=500)
-def hconfig(key: ConfigEnum, child_id: int | None = None) -> str | int | None:
+def hconfig(key: ConfigEnum, child_id: Optional[int] = None):  # -> str | int | StrEnum | None:
     if child_id is None:
-        child_id = Child.current.id
+        child_id = Child.current().id
 
     value = None
     try:
@@ -63,14 +83,18 @@ def hconfig(key: ConfigEnum, child_id: int | None = None) -> str | int | None:
     except BaseException:
         error(f'{key} error!')
         raise
-    if key.type == int and value != None:
-        return int(value)
+    if value != None:
+        if key.type == int:
+            return int(value)
+        elif hasattr(key.type, 'from_str'):
+            return key.type.from_str(value)
+
     return value
 
 
 def set_hconfig(key: ConfigEnum, value: str | int | bool, child_id: int | None = None, commit: bool = True):
     if child_id is None:
-        child_id = Child.current.id
+        child_id = Child.current().id
 
     print(f"chainging .... {key}---{value}---{child_id}---{commit}")
     if key.type == int and value != None:
@@ -81,7 +105,7 @@ def set_hconfig(key: ConfigEnum, value: str | int | bool, child_id: int | None =
     hconfig.invalidate(key, child_id)
     hconfig.invalidate(key, child_id=child_id)
     hconfig.invalidate(key=key, child_id=child_id)
-    if child_id == Child.current.id:
+    if child_id == Child.current().id:
         hconfig.invalidate(key)
     # hconfig.invalidate_all()
     get_hconfigs.invalidate_all()
@@ -115,7 +139,7 @@ def set_hconfig(key: ConfigEnum, value: str | int | bool, child_id: int | None =
 @cache.cache(ttl=500,)
 def get_hconfigs(child_id: int | None = None, json=False) -> dict:
     if child_id is None:
-        child_id = Child.current.id
+        child_id = Child.current().id
 
     return {**{f'{u.key}' if json else u.key: u.value for u in BoolConfig.query.filter(BoolConfig.child_id == child_id).all() if u.key.type == bool},
             **{f'{u.key}' if json else u.key: int(u.value) if u.key.type == int and u.value != None else u.value for u in StrConfig.query.filter(StrConfig.child_id == child_id).all() if u.key.type != bool},
@@ -131,9 +155,9 @@ def get_hconfigs_childs(child_ids: list[int], json=False):
     return {c: get_hconfigs(c, json) for c in child_ids}
 
 
-def add_or_update_config(commit: bool = True, child_id: int = None, override_unique_id: bool = True, **config):
+def add_or_update_config(commit: bool = True, child_id: int | None = None, override_unique_id: bool = True, **config):
     if child_id is None:
-        child_id = Child.current.id
+        child_id = Child.current().id
     c = config['key']
     ckey = ConfigEnum(c)
     if c == ConfigEnum.unique_id and not override_unique_id:
@@ -145,13 +169,13 @@ def add_or_update_config(commit: bool = True, child_id: int = None, override_uni
     set_hconfig(ckey, v, child_id, commit=commit)
 
 
-def bulk_register_configs(hconfigs, commit: bool = True, override_child_unique_id: int | None = None, override_unique_id: bool = True):
+def bulk_register_configs(hconfigs, commit: bool = True, froce_child_unique_id: str | None = None, override_unique_id: bool = True):
     from hiddifypanel.panel import hiddify
     for conf in hconfigs:
         # print(conf)
         if conf['key'] == ConfigEnum.unique_id and not override_unique_id:
             continue
-        child_id = hiddify.get_child(unique_id=None)
+        child_id = hiddify.get_child(unique_id=froce_child_unique_id)
         # print(conf, child_id, conf.get('child_unique_id', None), override_child_unique_id)
         add_or_update_config(commit=False, child_id=child_id, **conf)
     if commit:

hiddifypanel/models/config_enum.py

@@ -5,7 +5,13 @@ from strenum import StrEnum
 from fast_enum import FastEnum
 
 
-class Lang(StrEnum):
+class HEnum(StrEnum):
+    @classmethod
+    def from_str(cls, key: str) -> 'HEnum':
+        return cls[key]
+
+
+class Lang(HEnum):
     en = auto()
     fa = auto()
     ru = auto()
@@ -13,6 +19,22 @@ class Lang(StrEnum):
     zh = auto()
 
 
+class PanelMode(HEnum):
+    standalone = auto()
+    parent = auto()
+    child = auto()
+
+
+class LogLevel(HEnum):
+    TRACE = auto()
+    DEBUG = auto()
+    INFO = auto()
+    SUCCESS = auto()
+    WARNING = auto()
+    ERROR = auto()
+    CRITICAL = auto()
+
+
 class ConfigCategory(StrEnum):
     admin = auto()
     branding = auto()
@@ -59,11 +81,15 @@ def _IntConfigDscr(category: ConfigCategory, apply_mode: ApplyMode = ApplyMode.n
     return category, apply_mode, int, show_in_parent
 
 
+def _TypedConfigDscr(ctype: type, category: ConfigCategory, apply_mode: ApplyMode = ApplyMode.nothing, show_in_parent: bool = True, hide_in_virtual_child=False):
+    return category, apply_mode, ctype, show_in_parent
+
+
 class ConfigEnum(metaclass=FastEnum):
     # category: ConfigCategory
-    __slots__ = ('category', 'apply_mode', 'type', 'show_in_parent', 'hide_in_virtual_child')
+    __slots__ = ('name', 'value', 'category', 'apply_mode', 'type', 'show_in_parent', 'hide_in_virtual_child')
 
-    def __init__(self, category: ConfigCategory, apply_mode: ApplyMode = ApplyMode.apply, ctype=str, show_in_parent: bool = True, hide_in_virtual_child=False, name=auto):
+    def __init__(self, category: ConfigCategory, apply_mode: ApplyMode = ApplyMode.apply, ctype=type, show_in_parent: bool = True, hide_in_virtual_child=False, name=auto):
         self.value = name
         self.name = name
         self.category = category
@@ -110,13 +136,27 @@ class ConfigEnum(metaclass=FastEnum):
     package_mode = _StrConfigDscr(ConfigCategory.advanced, hide_in_virtual_child=True)
     utls = _StrConfigDscr(ConfigCategory.advanced)
     telegram_bot_token = _StrConfigDscr(ConfigCategory.telegram, ApplyMode.apply, hide_in_virtual_child=True)
+
+    # region child-parent
+    # deprecated
     is_parent = _BoolConfigDscr(ConfigCategory.hidden)
-    parent_panel = _StrConfigDscr(ConfigCategory.hidden)
+    # parent panel domain
+    parent_panel = _StrConfigDscr(ConfigCategory.hidden)  # should be able to change by user
+    parent_domain = _StrConfigDscr(ConfigCategory.hidden)
+    parent_admin_proxy_path = _StrConfigDscr(ConfigCategory.hidden)
+
+    # the panel mode could be one of these: "parent", "child", "standalone"
+    # this config value would be 'standalone' by default. and would be set by panel itself
+    panel_mode = _TypedConfigDscr(PanelMode, ConfigCategory.hidden, ApplyMode.nothing, hide_in_virtual_child=True)
+    # endregion
+
+    log_level = _TypedConfigDscr(LogLevel, ConfigCategory.hidden, ApplyMode.restart, hide_in_virtual_child=True)
+
     unique_id = _StrConfigDscr(ConfigCategory.hidden)
     last_hash = _StrConfigDscr(ConfigCategory.hidden)
     cdn_forced_host = _StrConfigDscr(ConfigCategory.hidden)  # removed
-    lang = _StrConfigDscr(ConfigCategory.branding)
-    admin_lang = _StrConfigDscr(ConfigCategory.admin)
+    lang = _TypedConfigDscr(Lang, ConfigCategory.branding)
+    admin_lang = _TypedConfigDscr(Lang, ConfigCategory.admin)
     admin_secret = _StrConfigDscr(ConfigCategory.hidden)  # removed
 
     # tls
@@ -199,6 +239,13 @@ class ConfigEnum(metaclass=FastEnum):
     ws_enable = _BoolConfigDscr(ConfigCategory.proxies, ApplyMode.apply)
     grpc_enable = _BoolConfigDscr(ConfigCategory.proxies, ApplyMode.apply)
     httpupgrade_enable = _BoolConfigDscr(ConfigCategory.proxies, ApplyMode.apply)
+    vless_enable = _BoolConfigDscr(ConfigCategory.proxies, ApplyMode.apply)
+    trojan_enable = _BoolConfigDscr(ConfigCategory.proxies, ApplyMode.apply)
+    reality_enable = _BoolConfigDscr(ConfigCategory.proxies, ApplyMode.apply)
+    tcp_enable = _BoolConfigDscr(ConfigCategory.proxies, ApplyMode.apply)
+    quic_enable = _BoolConfigDscr(ConfigCategory.proxies, ApplyMode.apply)
+    xtls_enable = _BoolConfigDscr(ConfigCategory.proxies, ApplyMode.apply)
+    h2_enable = _BoolConfigDscr(ConfigCategory.proxies, ApplyMode.apply)
 
     db_version = _StrConfigDscr(ConfigCategory.hidden, ApplyMode.apply)
 
@@ -234,7 +281,7 @@ class ConfigEnum(metaclass=FastEnum):
         return not self.__eq__(other)
 
     def endswith(self, other):
-        return self.name.endswith(other)
+        return self.name.endswith(other)  # type: ignore
 
     def startswith(self, other):
-        return self.name.startswith(other)
+        return self.name.startswith(other)  # type: ignore