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

hiddifypanel/hutils/importer/xui.py

@@ -6,15 +6,18 @@ from datetime import datetime
 from dateutil.relativedelta import relativedelta
 from hiddifypanel import hutils
 from hiddifypanel.models import *
-from hiddifypanel.database import db
+from hiddifypanel.database import db, db_execute
 import os
+from sqlalchemy import text
 
 
 def __query_fetch_json(db, query: str, args: Tuple = ()) -> List[Dict[str, Any]]:
     try:
-        db.execute(query, args) if args else db.execute(query)
+
+        db_execute(query, args)
         r = [dict((db.description[i][0], value)
                   for i, value in enumerate(row)) for row in db.fetchall()]
+        connection.close()
         return r
     except Exception as err:
         raise err

hiddifypanel/hutils/node/__init__.py

@@ -0,0 +1,3 @@
+from .shared import *
+from . import child
+from . import parent

hiddifypanel/hutils/node/api_client.py

@@ -0,0 +1,76 @@
+from typing import Optional, Union, Type
+from apiflask import Schema, fields
+import traceback
+import requests
+from loguru import logger
+from hiddifypanel.models import hconfig, ConfigEnum
+
+
+class NodeApiErrorSchema(Schema):
+    msg = fields.String(required=True)
+    stacktrace = fields.String(required=True)
+    code = fields.Integer(required=True)
+    reason = fields.String(required=True)
+
+
+class NodeApiClient():
+    def __init__(self, base_url: str, apikey: Optional[str] = None, max_retry: int = 3):
+        self.base_url = base_url if base_url.endswith('/') else base_url+'/'
+        self.max_retry = max_retry
+        self.headers = {'Hiddify-API-Key': apikey or hconfig(ConfigEnum.unique_id)}
+
+    def __call(self, method: str, path: str, payload: Optional[Schema], output_schema: Type[Union[Schema, dict]]) -> Union[dict, NodeApiErrorSchema]:  # type: ignore
+        retry_count = 1
+        full_url = self.base_url + path.removeprefix('/')
+        while 1:
+            try:
+                # TODO: implement it with aiohttp
+
+                logger.trace(f"Attempting {method} request to node at {full_url}")
+
+                # send request
+                if payload:
+                    response = requests.request(method, full_url, json=payload.dump(payload), headers=self.headers)
+                else:
+                    response = requests.request(method, full_url, headers=self.headers)
+
+                # parse response
+                response.raise_for_status()
+                resp = response.json()
+                if not resp:
+                    err = NodeApiErrorSchema()
+                    err.msg = 'Empty response'  # type: ignore
+                    err.stacktrace = ''  # type: ignore
+                    err.code = response.status_code  # type: ignore
+                    err.reason = response.reason  # type: ignore
+                    with logger.contextualize(payload=payload):
+                        logger.warning(f"Received empty response from {full_url} with method {method}")
+                    return err
+
+                logger.trace(f"Successfully received response from {full_url}")
+                return resp if isinstance(output_schema, type(dict)) else output_schema().load(resp)  # type: ignore
+
+            except requests.HTTPError as e:
+                if retry_count >= self.max_retry:
+                    stack_trace = traceback.format_exc()
+                    err = NodeApiErrorSchema()
+                    err.msg = str(e)  # type: ignore
+                    err.stacktrace = stack_trace  # type: ignore
+                    err.code = response.status_code  # type: ignore
+                    err.reason = response.reason  # type: ignore
+                    with logger.contextualize(status_code=err.code, reason=err.reason, stack_trace=stack_trace, payload=payload):
+                        logger.error(f"HTTP error after {self.max_retry} retries")
+                        logger.exception(e)
+                    return err
+
+                logger.warning(f"Error occurred: {e} from {full_url} with method {method}, retrying... ({retry_count}/{self.max_retry})")
+                retry_count += 1
+
+    def get(self, path: str, output: Type[Union[Schema, dict]]) -> Union[dict, NodeApiErrorSchema]:
+        return self.__call("GET", path, None, output)
+
+    def post(self, path: str, payload: Optional[Schema], output: Type[Union[Schema, dict]]) -> Union[dict, NodeApiErrorSchema]:
+        return self.__call("POST", path, payload, output)
+
+    def put(self, path: str, payload: Optional[Schema], output: Type[Union[Schema, dict]]) -> Union[dict, NodeApiErrorSchema]:
+        return self.__call("PUT", path, payload, output)

hiddifypanel/hutils/node/child.py

@@ -0,0 +1,147 @@
+from loguru import logger
+import socket
+
+from hiddifypanel.models import AdminUser, User, hconfig, ConfigEnum, ChildMode, set_hconfig, Domain, Proxy, StrConfig, BoolConfig, Child, ChildMode
+from hiddifypanel import hutils
+from hiddifypanel.panel import hiddify
+from hiddifypanel.panel import usage
+from hiddifypanel.database import db
+from hiddifypanel.cache import cache
+
+# import schmeas
+from hiddifypanel.panel.commercial.restapi.v2.parent.schema import *
+from hiddifypanel.panel.commercial.restapi.v2.child.schema import *
+
+from .api_client import NodeApiClient, NodeApiErrorSchema
+# region private
+
+
+def __get_register_data_for_api(name: str, mode: ChildMode) -> RegisterInputSchema:
+
+    register_data = RegisterInputSchema()
+    register_data.unique_id = hconfig(ConfigEnum.unique_id)
+    register_data.name = name  # type: ignore
+    register_data.mode = mode  # type: ignore
+
+    panel_data = RegisterDataSchema()  # type: ignore
+    panel_data.admin_users = [admin_user.to_schema() for admin_user in AdminUser.query.all()]  # type: ignore
+    panel_data.users = [user.to_schema() for user in User.query.all()]  # type: ignore
+    panel_data.domains = [domain.to_schema() for domain in Domain.query.all()]  # type: ignore
+    panel_data.proxies = [proxy.to_schema() for proxy in Proxy.query.all()]  # type: ignore
+    panel_data.hconfigs = [*[u.to_schema() for u in StrConfig.query.all()], *[u.to_schema() for u in BoolConfig.query.all()]]  # type: ignore
+    register_data.panel_data = panel_data
+
+    return register_data
+
+
+def __get_sync_data_for_api() -> 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
+
+    return sync_data
+
+
+def __get_parent_panel_url() -> str:
+    url = 'https://' + f"{hconfig(ConfigEnum.parent_domain).removesuffix('/')}/{hconfig(ConfigEnum.parent_admin_proxy_path).removesuffix('/')}"
+    return url
+
+# endregion
+
+
+def is_registered() -> bool:
+    '''Checks if the current parent registered as a child'''
+    try:
+        logger.debug("Checking if current panel is registered with parent")
+        base_url = __get_parent_panel_url()
+        if not base_url:
+            return False
+        payload = ChildStatusInputSchema()
+        payload.child_unique_id = hconfig(ConfigEnum.unique_id)
+
+        res = NodeApiClient(base_url).post('/api/v2/parent/status/', payload, ChildStatusOutputSchema)
+        if isinstance(res, NodeApiErrorSchema):
+            logger.error(f"Error while checking if current panel is registered with parent: {res.msg}")
+            return False
+
+        if res['existance']:
+            return True
+        return False
+    except Exception as e:
+        logger.error(f"Error while checking if current panel is registered with parent")
+        logger.exception(e)
+        return False
+
+
+def register_to_parent(name: str, apikey: str, mode: ChildMode = ChildMode.remote) -> bool:
+    # get parent link its format is "https://panel.hiddify.com/<admin_proxy_path>/"
+    p_url = __get_parent_panel_url()
+    if not p_url:
+        logger.error("Parent url is empty")
+        return False
+
+    payload = __get_register_data_for_api(name, mode)
+    res = NodeApiClient(p_url, apikey).put('/api/v2/parent/register/', payload, RegisterOutputSchema)
+    if isinstance(res, NodeApiErrorSchema):
+        logger.error(f"Error while registering to parent: {res.msg}")
+        return False
+
+    # TODO: change the bulk_register and such methods to accept models instead of dict
+    AdminUser.bulk_register(res['admin_users'], commit=False)
+    User.bulk_register(res['users'], commit=False)
+
+    # add new child as parent
+    db.session.add(  # type: ignore
+        Child(unique_id=res['parent_unique_id'], name=socket.gethostname() or res['parent_unique_id'], mode=ChildMode.parent)
+    )
+
+    db.session.commit()  # type: ignore
+
+    logger.success("Successfully registered to parent")
+    cache.invalidate_all_cached_functions()
+    return True
+
+
+def sync_with_parent() -> bool:
+    # sync usage first
+    if not sync_users_usage_with_parent():
+        logger.error("Error while syncing with parent: Failed to sync users usage")
+        return False
+
+    p_url = __get_parent_panel_url()
+    if not p_url:
+        logger.error("Error while syncing with parent: Parent url is empty")
+        return False
+    payload = __get_sync_data_for_api()
+    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}")
+        return False
+    AdminUser.bulk_register(res['admin_users'], commit=False, remove=True)
+    User.bulk_register(res['users'], commit=False, remove=True)
+    db.session.commit()  # type: ignore
+    logger.success("Successfully synced with parent")
+    cache.invalidate_all_cached_functions()
+    return True
+
+
+def sync_users_usage_with_parent() -> bool:
+    p_url = __get_parent_panel_url()
+    if not p_url:
+        logger.error("Parent url is empty")
+        return False
+
+    payload = hutils.node.get_users_usage_data_for_api()
+    if payload:
+        res = NodeApiClient(p_url).put('/api/v2/parent/usage/', payload, UsageInputOutputSchema)  # type: ignore
+        if isinstance(res, NodeApiErrorSchema):
+            logger.error(f"Error while syncing users usage with parent: {res.msg}")
+            return False
+
+        # parse usages data
+        res = hutils.node.convert_usage_api_response_to_dict(res)  # type: ignore
+        usage.add_users_usage_uuid(res, hiddify.get_child(None), True)
+        logger.success(f"Successfully synced users usage with parent: {res}")
+
+    return True

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