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

hiddifypanel/models/domain.py

@@ -4,7 +4,7 @@ from typing import List
 from urllib.parse import urlparse
 
 from flask import request
-from sqlalchemy_serializer import SerializerMixin
+
 from flask_babel import lazy_gettext as _
 from sqlalchemy.orm import backref
 from urllib.parse import urlparse
@@ -40,7 +40,7 @@ ShowDomain = db.Table('show_domain',
                       )
 
 
-class Domain(db.Model, SerializerMixin):
+class Domain(db.Model):
     id = db.Column(db.Integer, primary_key=True, autoincrement=True)
     child_id = db.Column(db.Integer, db.ForeignKey('child.id'), default=0)
     domain = db.Column(db.String(200), nullable=False, unique=False)
@@ -67,7 +67,7 @@ class Domain(db.Model, SerializerMixin):
             'domain': self.domain.lower(),
             'mode': self.mode,
             'alias': self.alias,
-            # 'sub_link_only':d.sub_link_only,
+            'sub_link_only': self.sub_link_only,
             'child_unique_id': self.child.unique_id if self.child else '',
             'cdn_ip': self.cdn_ip,
             'servernames': self.servernames,
@@ -84,6 +84,15 @@ class Domain(db.Model, SerializerMixin):
 
         return data
 
+    @staticmethod
+    def from_schema(schema):
+        return schema.dump(Domain())
+
+    def to_schema(self):
+        domain_dict = self.to_dict()
+        from hiddifypanel.panel.commercial.restapi.v2.parent.schema import DomainSchema
+        return DomainSchema().load(domain_dict)
+
     @property
     def need_valid_ssl(self):
         return self.mode in [DomainType.direct, DomainType.cdn, DomainType.worker, DomainType.relay, DomainType.auto_cdn_ip, DomainType.old_xtls_direct, DomainType.sub_link_only]
@@ -137,14 +146,22 @@ def get_domain(domain):
     return Domain.query.filter(Domain.domain == domain).first()
 
 
+def get_panel_link(child_id: int | None = None) -> Domain | None:
+    if child_id is None:
+        child_id = Child.current().id
+    domains = Domain.query.filter(Domain.mode.in_(
+        [DomainType.direct, DomainType.cdn, DomainType.worker, DomainType.relay, DomainType.auto_cdn_ip, DomainType.old_xtls_direct, DomainType.sub_link_only]),
+        Domain.child_id == child_id
+    ).all()
+    if not domains:
+        return None
+    return domains[0]
+
+
 def get_panel_domains(always_add_ip=False, always_add_all_domains=False) -> List[Domain]:
     from hiddifypanel import hutils
     domains = []
-    # if hconfig(ConfigEnum.is_parent):
-    #     from .parent_domain import ParentDomain
-    #     domains = ParentDomain.query.all()
-    # else:
-    domains = Domain.query.filter(Domain.mode == DomainType.sub_link_only, Domain.child_id == Child.current.id).all()
+    domains = Domain.query.filter(Domain.mode == DomainType.sub_link_only, Domain.child_id == Child.current().id).all()
     if not len(domains) or always_add_all_domains:
         domains = Domain.query.filter(Domain.mode.notin_([DomainType.fake, DomainType.reality])).all()
 
@@ -156,11 +173,7 @@ def get_panel_domains(always_add_ip=False, always_add_all_domains=False) -> List
 
 
 def get_proxy_domains(domain):
-    # if hconfig(ConfigEnum.is_parent):
-    #     from hiddifypanel.models.parent_domain import ParentDomain
-    #     db_domain = ParentDomain.query.filter(ParentDomain.domain == domain).first() or ParentDomain(domain=domain, show_domains=[])
-    # else:
-    db_domain = Domain.query.filter(Domain.domain == domain, Domain.child_id == Child.current.id).first()
+    db_domain = Domain.query.filter(Domain.domain == domain, Domain.child_id == Child.current().id).first()
     if not db_domain:
         db_domain = Domain(domain=domain, mode=DomainType.direct, cdn_ip='', show_domains=[])
     return get_proxy_domains_db(db_domain)
@@ -202,11 +215,11 @@ def add_or_update_domain(commit=True, child_id=0, **domain):
         db.session.commit()
 
 
-def bulk_register_domains(domains, commit=True, remove=False, override_child_unique_id=None):
+def bulk_register_domains(domains, commit=True, remove=False, force_child_unique_id: str | None = None):
     from hiddifypanel.panel import hiddify
     child_ids = {}
     for domain in domains:
-        child_id = hiddify.get_child(unique_id=None)
+        child_id = hiddify.get_child(unique_id=force_child_unique_id)
         child_ids[child_id] = 1
         add_or_update_domain(commit=False, child_id=child_id, **domain)
     if remove and len(child_ids):
@@ -215,10 +228,5 @@ def bulk_register_domains(domains, commit=True, remove=False, override_child_uni
             if d.domain not in dd:
                 db.session.delete(d)
 
-    # if commit:
-    db.session.commit()
-    for domain in domains:
-        child_id = hiddify.get_child(unique_id=None)
-        add_or_update_domain(commit=False, child_id=child_id, **domain)
     if commit:
         db.session.commit()

hiddifypanel/models/parent_domain.py

@@ -1,6 +1,6 @@
 # from hiddifypanel.models.domain import Domain
 # from sqlalchemy.orm import backref
-# from sqlalchemy_serializer import SerializerMixin
+#
 
 # from hiddifypanel.database import db
 
@@ -10,7 +10,7 @@
 #                             )
 
 
-# class ParentDomain(db.Model, SerializerMixin):
+# class ParentDomain(db.Model):
 #     id = db.Column(db.Integer, primary_key=True, autoincrement=True)
 #     domain = db.Column(db.String(200), nullable=False, unique=True)
 #     alias = db.Column(db.String(200), nullable=False, unique=False)

hiddifypanel/models/proxy.py

@@ -1,4 +1,4 @@
-from sqlalchemy_serializer import SerializerMixin
+
 from strenum import StrEnum
 from enum import auto
 from sqlalchemy import Column, String, Integer, Boolean, Enum, ForeignKey
@@ -57,7 +57,7 @@ class ProxyL3(StrEnum):
     custom = auto()
 
 
-class Proxy(db.Model, SerializerMixin):  # type: ignore
+class Proxy(db.Model):  # type: ignore
     id = Column(Integer, primary_key=True, autoincrement=True)
     child_id = Column(Integer, ForeignKey('child.id'), default=0)
     name = Column(String(200), nullable=False, unique=False)
@@ -102,10 +102,19 @@ class Proxy(db.Model, SerializerMixin):  # type: ignore
             db.session.commit()  # type: ignore
 
     @staticmethod
-    def bulk_register(proxies, commit=True, override_child_unique_id=None):
+    def from_schema(schema):
+        return schema.dump(Proxy())
+
+    def to_schema(self):
+        proxy_dict = self.to_dict()
+        from hiddifypanel.panel.commercial.restapi.v2.parent.schema import ProxySchema
+        return ProxySchema().load(proxy_dict)
+
+    @staticmethod
+    def bulk_register(proxies, commit=True, force_child_unique_id: str | None = None):
         from hiddifypanel.panel import hiddify
         for proxy in proxies:
-            child_id = hiddify.get_child(unique_id=None)
+            child_id = hiddify.get_child(unique_id=force_child_unique_id)
             Proxy.add_or_update(commit=False, child_id=child_id, **proxy)
         if commit:
             db.session.commit()  # type: ignore

hiddifypanel/models/report.py

@@ -1,11 +1,10 @@
 import datetime
 
-from sqlalchemy_serializer import SerializerMixin
 
 from hiddifypanel.database import db
 
 
-class Report(db.Model, SerializerMixin):
+class Report(db.Model):
     id = db.Column(db.Integer, primary_key=True, autoincrement=True)
     user_id = db.Column(db.Integer, db.ForeignKey('user.id'), default=0, nullable=False)
     asn_id = db.Column(db.String(200), nullable=False, unique=False)
@@ -19,7 +18,7 @@ class Report(db.Model, SerializerMixin):
     details = db.relationship('ReportDetail', cascade="all,delete", backref='report', lazy='dynamic',)
 
 
-class ReportDetail(db.Model, SerializerMixin):
+class ReportDetail(db.Model):
     report_id = db.Column(db.Integer, db.ForeignKey('report.id'), primary_key=True, )
     proxy_id = db.Column(db.Integer, db.ForeignKey('proxy.id'), primary_key=True, )
     ping = db.Column(db.Integer, default=-1)

hiddifypanel/models/usage.py

@@ -3,12 +3,12 @@ from datetime import timedelta, date
 
 from flask import g
 from sqlalchemy import func
-from sqlalchemy_serializer import SerializerMixin
+
 
 from hiddifypanel.database import db
 
 
-class DailyUsage(db.Model, SerializerMixin):
+class DailyUsage(db.Model):
     id = db.Column(db.Integer, primary_key=True, autoincrement=True)
     date = db.Column(db.Date, default=datetime.date.today(), index=True)
     usage = db.Column(db.BigInteger, default=0, nullable=False)

hiddifypanel/models/user.py

@@ -2,7 +2,7 @@ import datetime
 from enum import auto
 from hiddifypanel.models.role import Role
 from dateutil import relativedelta
-from sqlalchemy_serializer import SerializerMixin
+
 from strenum import StrEnum
 from sqlalchemy import event
 
@@ -35,7 +35,7 @@ package_mode_dic = {
 }
 
 
-class UserDetail(db.Model, SerializerMixin):
+class UserDetail(db.Model):
     id = db.Column(db.Integer, primary_key=True, autoincrement=True)
     user_id = db.Column(db.Integer, db.ForeignKey('user.id'), default=0, nullable=False)
     child_id = db.Column(db.Integer, db.ForeignKey('child.id'), default=0, nullable=False)
@@ -121,12 +121,12 @@ class User(BaseAccount):
             is_active = False
         elif self.remaining_days < 0:
             is_active = False
-        elif len(self.ips) > max(3, self.max_ips):
+        elif len(self.devices) > max(3, self.max_ips):
             is_active = False
         return is_active
 
     @property
-    def ips(self):
+    def devices(self):
         res = {}
         for detail in UserDetail.query.filter(UserDetail.user_id == self.id):
             for device in detail.devices:
@@ -256,6 +256,15 @@ class User(BaseAccount):
             db.session.commit()
         return dbuser
 
+    @staticmethod
+    def form_schema(schema):
+        return schema.dump(User())
+
+    def to_schema(self):
+        user_dict = self.to_dict()
+        from hiddifypanel.panel.commercial.restapi.v2.admin.user_api import UserSchema
+        return UserSchema().load(user_dict)
+
     def to_dict(self, convert_date=True, dump_id=False) -> dict:
         base = super().to_dict()
         from hiddifypanel import hutils

hiddifypanel/panel/admin/Actions.py

@@ -61,11 +61,9 @@ class Actions(FlaskView):
     def reinstall2(self, complete_install=True, domain_changed=False):
         if int(hconfig(ConfigEnum.db_version)) < 9:
             return ("Please update your panel before this action.")
-        # if hconfig(ConfigEnum.parent_panel):
-        #     try:
-        #         hiddify_api.sync_child_to_parent()
-        #     except e as Exception:
-        #         hutils.flask.flash(_('can not sync child with parent panel')+" "+e)
+        if hutils.node.is_child():
+            if not hutils.node.child.sync_with_parent():
+                hutils.flask.flash(_('child.sync-failed'), 'danger')  # type: ignore
 
         domain_changed = request.args.get("domain_changed", str(domain_changed)).lower() == "true"
         complete_install = request.args.get("complete_install", str(complete_install)).lower() == "true"
@@ -110,7 +108,7 @@ class Actions(FlaskView):
 
     @login_required(roles={Role.super_admin})
     def change_reality_keys(self):
-        key = hiddify.generate_x25519_keys()
+        key = hutils.crypto.generate_x25519_keys()
         set_hconfig(ConfigEnum.reality_private_key, key['private_key'])
         set_hconfig(ConfigEnum.reality_public_key, key['public_key'])
         hutils.flask.flash_config_success(restart_mode=ApplyMode.restart, domain_changed=False)

hiddifypanel/panel/admin/AdminstratorAdmin.py

@@ -7,7 +7,9 @@ from .adminlte import AdminLTEModelView
 from flask_babel import lazy_gettext as _
 from wtforms.validators import Regexp
 from flask_babel import gettext as __
-from flask import Markup, request  # type: ignore
+from flask import request  # type: ignore
+from markupsafe import Markup
+
 from flask import g
 import datetime
 from wtforms import SelectField
@@ -37,7 +39,7 @@ class SubAdminsField(SelectField):
 
 class AdminstratorAdmin(AdminLTEModelView):
     column_hide_backrefs = False
-    column_list = ["name", 'UserLinks', 'mode', 'can_add_admin', 'max_active_users', 'max_users', 'online_users', 'comment']
+    column_list = ["name", 'UserLinks', 'mode', 'can_add_admin', 'max_active_users', 'max_users', 'online_users', 'comment',]
     form_columns = ["name", 'mode', 'can_add_admin', 'max_active_users', 'max_users', 'comment', "uuid"]
     list_template = 'model/admin_list.html'
     # column_editable_list = ['name']
@@ -215,6 +217,7 @@ class AdminstratorAdmin(AdminLTEModelView):
         model.remove()
 
     def get_query_for_parent_admin(self):
+        # WHAT IS THIS?
         admin_user_id = self.get_pk_value()
         sub_admins_ids = set(recursive_sub_admins_ids(AdminUser.query.get(admin_user_id)))
         return AdminUser.query.filter(AdminUser.id.in_(sub_admins_ids)).with_entities(AdminUser.id, AdminUser.name)
@@ -236,3 +239,11 @@ class AdminstratorAdmin(AdminLTEModelView):
             del form.max_users
             del form.max_active_users
             del form.can_add_admin
+
+    def after_model_change(self, form, model, is_created):
+        if hutils.node.is_parent():
+            hutils.node.parent.send_sync_req_to_childs()
+
+    def after_model_delete(self, model):
+        if hutils.node.is_parent():
+            hutils.node.parent.send_sync_req_to_childs()

hiddifypanel/panel/admin/Dashboard.py

@@ -18,9 +18,9 @@ class Dashboard(FlaskView):
 
     @login_required(roles={Role.super_admin, Role.admin, Role.agent})
     def index(self):
-
         if hconfig(ConfigEnum.first_setup):
             return redirect(hurl_for("admin.QuickSetup:index"))
+
         if hiddifypanel.__release_date__ + datetime.timedelta(days=20) < datetime.datetime.now():
             hutils.flask.flash(_('This version of hiddify panel is outdated. Please update it from admin area.'), "danger")  # type: ignore
         bot = None
@@ -34,20 +34,15 @@ class Dashboard(FlaskView):
         user_query = User.query
         if admin_id:
             user_query = user_query.filter(User.added_by == admin_id)
-        if hconfig(ConfigEnum.is_parent):
+        if hutils.node.is_parent():
             childs = Child.query.filter(Child.id != 0).all()
             for c in childs:
                 c.is_active = False
                 for d in c.domains:
-                    if d.mode == DomainType.fake:
-                        continue
-                    remote = hiddify.get_account_panel_link(g.account, d.domain, child_id=c.id)
-                    d.is_active = hutils.network.check_connection_to_remote(remote)
+                    d.is_active = hutils.node.parent.is_child_domain_active(c, d)
                     if d.is_active:
                         c.is_active = True
 
-            # return render_template('parent_dash.html',childs=childs,bot=bot)
-    # try:
         def_user = None if len(User.query.all()) > 1 else User.query.filter(User.name == 'default').first()
         domains = get_panel_domains()
         sslip_domains = [d.domain for d in domains if "sslip.io" in d.domain]
@@ -56,13 +51,13 @@ class Dashboard(FlaskView):
             quick_setup = hurl_for("admin.QuickSetup:index")
             hutils.flask.flash((_('It seems that you have not setup the system completely. <a class="btn btn-success" href="%(quick_setup)s">Click here</a> to complete setup.',
                                   quick_setup=quick_setup)), 'warning')  # type: ignore
-            if hconfig(ConfigEnum.is_parent):
+            if hutils.node.is_parent():
                 hutils.flask.flash(
                     _("Please understand that parent panel is under test and the plan and the condition of use maybe change at anytime."), "danger")  # type: ignore
         elif len(sslip_domains):
             hutils.flask.flash((_('It seems that you are using default domain (%(domain)s) which is not recommended.',
                                domain=sslip_domains[0])), 'warning')  # type: ignore
-            if hconfig(ConfigEnum.is_parent):
+            if hutils.node.is_parent():
                 hutils.flask.flash(
                     _("Please understand that parent panel is under test and the plan and the condition of use maybe change at anytime."), "danger")  # type: ignore
         elif def_user:

hiddifypanel/panel/admin/DomainAdmin.py

@@ -3,7 +3,9 @@ from hiddifypanel.auth import login_required, current_account
 
 from hiddifypanel.models import *
 import re
-from flask import Markup, g  # type: ignore
+from flask import g  # type: ignore
+from markupsafe import Markup
+
 from flask_babel import gettext as __
 from flask_babel import lazy_gettext as _
 from hiddifypanel.panel.run_commander import Command, commander
@@ -229,7 +231,7 @@ class DomainAdmin(AdminLTEModelView):
                     if not d:
                         continue
                     if not hutils.network.is_domain_reality_friendly(d):
-                        raise ValidationError(_("Domain is not REALITY friendly!")+f' {d}')
+                        raise ValidationError(_("Domain is not REALITY friendly!") + f' {d}')
 
                     if not hutils.network.is_in_same_asn(d, ipv4_list[0]):
                         server_asn = hutils.network.get_ip_asn_name(ipv4_list[0])
@@ -240,7 +242,7 @@ class DomainAdmin(AdminLTEModelView):
 
             for d in model.servernames.split(","):
                 if not hutils.network.fallback_domain_compatible_with_servernames(model.domain, d):
-                    raise ValidationError(_("REALITY Fallback domain is not compaitble with server names!")+f' {d} != {model.domain}')
+                    raise ValidationError(_("REALITY Fallback domain is not compaitble with server names!") + f' {d} != {model.domain}')
 
         if (model.cdn_ip):
             try:
@@ -266,19 +268,18 @@ class DomainAdmin(AdminLTEModelView):
         hutils.flask.flash_config_success(restart_mode=ApplyMode.apply, domain_changed=True)
 
     def after_model_delete(self, model):
-        # if hconfig(ConfigEnum.parent_panel):
-        #     hiddify_api.sync_child_to_parent()
-        pass
+        if hutils.node.is_child():
+            if not hutils.node.child.sync_with_parent():
+                hutils.flask.flash(_('child.sync-failed'), 'danger')  # type: ignore
 
     def after_model_change(self, form, model, is_created):
         if hconfig(ConfigEnum.first_setup):
             set_hconfig(ConfigEnum.first_setup, False)
-        # if hconfig(ConfigEnum.parent_panel):
-        #     hiddify_api.sync_child_to_parent()
         if model.need_valid_ssl:
-            # hiddify.exec_command(f"sudo /opt/hiddify-manager/acme.sh/get_cert.sh {model.domain}")
-            # run get_cert.sh
             commander(Command.get_cert, domain=model.domain)
+        if hutils.node.is_child():
+            if not hutils.node.child.sync_with_parent():
+                hutils.flask.flash(_('child.sync-failed'), 'danger')  # type: ignore
 
     def is_accessible(self):
         if login_required(roles={Role.super_admin, Role.admin})(lambda: True)() != True:
@@ -296,4 +297,4 @@ class DomainAdmin(AdminLTEModelView):
 
     def get_query(self):
         query = super().get_query()
-        return query.filter(Domain.child_id == Child.current.id)
+        return query.filter(Domain.child_id == Child.current().id)

hiddifypanel/panel/admin/NodeAdmin.py

@@ -4,7 +4,9 @@ from wtforms.validators import Regexp, ValidationError
 from flask_babel import lazy_gettext as _
 from .adminlte import AdminLTEModelView
 from flask_babel import gettext as __
-from flask import Markup, g, request
+from flask import g, request
+from markupsafe import Markup
+
 
 from hiddifypanel.auth import login_required
 from hiddifypanel.panel import hiddify
@@ -40,7 +42,7 @@ class NodeAdmin(AdminLTEModelView):
     def is_accessible(self):
         if login_required(roles={Role.super_admin})(lambda: True)() != True:
             return False
-        if Child.current.id != 0:
+        if Child.current().id != 0:
             return False
         return True
 
@@ -49,7 +51,9 @@ class NodeAdmin(AdminLTEModelView):
             raise ValidationError(_("Remote nodes are not supported yet!"))
 
     def after_model_change(self, form, model, is_created):
+        # deprecated
         set_hconfig(ConfigEnum.is_parent, True)
+        set_hconfig(ConfigEnum.panel_mode, PanelMode.parent)
         if is_created and model.mode == ChildMode.virtual:
             # for k, v in get_hconfigs().items():
             #     set_hconfig(k, v, model.id)

hiddifypanel/panel/admin/ProxyAdmin.py

@@ -56,9 +56,10 @@ class ProxyAdmin(FlaskView):
                 # print(cat,vs)
             db.session.commit()
             hutils.proxy.get_proxies.invalidate_all()
+            if hutils.node.is_child():
+                if not hutils.node.child.sync_with_parent():
+                    hutils.flask.flash(_('child.sync-failed'), 'danger')  # type: ignore
             hutils.flask.flash_config_success(restart_mode=ApplyMode.apply, domain_changed=False)
-            # if hconfig(ConfigEnum.parent_panel):
-            #     hiddify_api.sync_child_to_parent()
             global_config_form = get_global_config_form(True)
         else:
             hutils.flask.flash((_('config.validation-error')), 'danger')
@@ -94,7 +95,7 @@ def get_global_config_form(empty=False):
 
 
 def get_all_proxy_form(empty=False):
-    proxies = hutils.proxy.get_proxies(Child.current.id)
+    proxies = hutils.proxy.get_proxies(Child.current().id)
     categories1 = sorted([c for c in {c.cdn: 1 for c in proxies}])
 
     class DynamicForm(FlaskForm):

hiddifypanel/panel/admin/SettingAdmin.py

@@ -3,7 +3,9 @@ import flask_babel
 import flask_babel
 from flask_babel import lazy_gettext as _
 # from flask_babelex import gettext as _
-from flask import render_template, Markup, g  # type: ignore
+from flask import render_template, g  # type: ignore
+from markupsafe import Markup
+
 from hiddifypanel.hutils.flask import hurl_for
 from flask import current_app as app
 from hiddifypanel import hutils
@@ -20,6 +22,7 @@ from hiddifypanel.models import BoolConfig, StrConfig, ConfigEnum, hconfig, Conf
 from hiddifypanel.models import *
 from hiddifypanel.database import db
 from hiddifypanel.panel import hiddify, custom_widgets
+from hiddifypanel import __version__
 
 
 class SettingAdmin(FlaskView):
@@ -36,26 +39,26 @@ class SettingAdmin(FlaskView):
         reset_action = None
         if form.validate_on_submit():
 
-            boolconfigs = BoolConfig.query.filter(BoolConfig.child_id == Child.current.id).all()
+            boolconfigs = BoolConfig.query.filter(BoolConfig.child_id == Child.current().id).all()
             bool_types = {c.key: 'bool' for c in boolconfigs}
 
             old_configs = get_hconfigs()
             changed_configs = {}
 
-            for cat, vs in form.data.items():  # [c for c in ConfigEnum]:
+            for category, c_items in form.data.items():  # [c for c in ConfigEnum]:
 
-                if isinstance(vs, dict):
+                if isinstance(c_items, dict):
                     for k in ConfigEnum:
-                        if k.name not in vs:
+                        if k.name not in c_items:
                             continue
-                        v = vs[k.name]
+                        v = c_items[k.name]
                         if k.type == str:
                             if "_domain" in k or "_fakedomain" in k:
                                 v = v.lower()
 
                             if "port" in k:
                                 for p in v.split(","):
-                                    for k2, v2 in vs.items():
+                                    for k2, v2 in c_items.items():
                                         if "port" in k2 and k.name != k2 and p in v2:
                                             hutils.flask.flash(_("Port is already used! in") + f" {k2} {k}", 'error')
                                             return render_template('config.html', form=form)
@@ -73,32 +76,63 @@ class SettingAdmin(FlaskView):
                 hutils.flask.flash(_("ProxyPath is already used! use different proxy path"), 'error')  # type: ignore
                 return render_template('config.html', form=form)
 
+            # validate parent_panel value
+            parent_apikey = ''
+            if p_p := changed_configs.get(ConfigEnum.parent_panel):
+                domain, proxy_path, uuid = hutils.flask.extract_parent_info_from_url(p_p)
+                if not domain or not proxy_path or not uuid or not hutils.node.is_panel_active(domain, proxy_path, uuid):
+                    hutils.flask.flash(_('parent.invalid-parent-url'), 'danger')  # type: ignore
+                    return render_template('config.html', form=form)
+                else:
+                    set_hconfig(ConfigEnum.parent_domain, domain)
+                    set_hconfig(ConfigEnum.parent_admin_proxy_path, proxy_path)
+                    parent_apikey = uuid
+
             for k, v in changed_configs.items():
                 set_hconfig(k, v, commit=False)
 
             db.session.commit()
             flask_babel.refresh()
 
+            # set panel mode
+            p_mode = hconfig(ConfigEnum.panel_mode)
+            if p_mode != PanelMode.parent:
+                if hconfig(ConfigEnum.parent_panel):
+                    if p_mode == PanelMode.standalone:
+                        set_hconfig(ConfigEnum.panel_mode, PanelMode.child)
+                else:
+                    if p_mode != PanelMode.standalone:
+                        set_hconfig(ConfigEnum.panel_mode, PanelMode.standalone)
+
             from hiddifypanel.panel.commercial.telegrambot import register_bot
             register_bot(set_hook=True)
-            # if hconfig(ConfigEnum.parent_panel):
-            #     hiddify_api.sync_child_to_parent()
+
+            # sync with parent if needed
+            if hutils.node.is_child():
+                if hutils.node.child.is_registered():
+                    if not hutils.node.child.sync_with_parent():
+                        hutils.flask.flash(_('child.sync-failed'), 'danger')  # type: ignore
+                    else:  # TODO: it's just for debuging
+                        hutils.flask.flash(_('child.sync-success'))  # type: ignore
+                else:
+                    name = hconfig(ConfigEnum.unique_id)
+                    parent_info = hutils.node.get_panel_info(hconfig(ConfigEnum.parent_domain), hconfig(ConfigEnum.parent_admin_proxy_path), parent_apikey)
+                    if parent_info.get('version') != __version__:
+                        hutils.flask.flash(_('node.diff-version'), 'danger')  # type: ignore
+                    if not hutils.node.child.register_to_parent(name, parent_apikey, mode=ChildMode.remote):
+                        hutils.flask.flash(_('child.register-failed'), 'danger')  # type: ignore
+                    else:  # TODO: it's just for debuging
+                        hutils.flask.flash(_('child.register-success'))  # type: ignore
+
             reset_action = hiddify.check_need_reset(old_configs)
 
             if old_configs[ConfigEnum.admin_lang] != hconfig(ConfigEnum.admin_lang):
-
                 form = get_config_form()
         else:
             hutils.flask.flash(_('config.validation-error'), 'danger')  # type: ignore
 
         return reset_action or render_template('config.html', form=form)
 
-        # # form=HelloForm()
-        # # # return render('config.html',form=form)
-        # # return render_template('config.html',form=HelloForm())
-        # form=get_config_form()
-        # return render_template('config.html',form=form)
-
     def get_babel_string(self):
         res = ""
         strconfigs = StrConfig.query.all()
@@ -122,8 +156,8 @@ class SettingAdmin(FlaskView):
 
 
 def get_config_form():
-    strconfigs = StrConfig.query.filter(StrConfig.child_id == Child.current.id).all()
-    boolconfigs = BoolConfig.query.filter(BoolConfig.child_id == Child.current.id).all()
+    strconfigs = StrConfig.query.filter(StrConfig.child_id == Child.current().id).all()
+    boolconfigs = BoolConfig.query.filter(BoolConfig.child_id == Child.current().id).all()
     bool_types = {c.key: 'bool' for c in boolconfigs}
 
     configs = [*boolconfigs, *strconfigs]
@@ -133,7 +167,7 @@ def get_config_form():
 
     class DynamicForm(FlaskForm):
         pass
-    is_parent = hconfig(ConfigEnum.is_parent)
+    is_parent = hutils.node.is_parent()
 
     for cat in ConfigCategory:
         if cat == 'hidden':
@@ -149,6 +183,9 @@ def get_config_form():
             if not (c2 in configs_key):
                 continue
             c = configs_key[c2]
+            if hutils.node.is_parent():
+                if c.key == ConfigEnum.parent_panel:
+                    continue
             extra_info = ''
             if c.key in bool_types:
                 field = SwitchField(_(f'config.{c.key}.label'), default=c.value, description=_(f'config.{c.key}.description'))
@@ -207,7 +244,9 @@ def get_config_form():
                 field = wtf.SelectField(_(f"config.{c.key}.label"), choices=choices, description=_(f"config.{c.key}.description"), default=hconfig(c.key))
 
             elif c.key == ConfigEnum.warp_sites:
-                validators = [wtf.validators.Length(max=2048)]
+                validators = [wtf.validators.Length(max=2048),
+                              wtf.validators.Regexp(r'^([\w.-]+)?(?:\n[\w.-]+)*$', re.IGNORECASE, _("config.invalid-pattern-for-warp-sites") + f' {c.key}')
+                              ]
                 render_kw = {'class': "ltr", 'maxlength': 2048}
                 field = wtf.TextAreaField(_(f'config.{c.key}.label'), validators, default=c.value,
                                           description=_(f'config.{c.key}.description'), render_kw=render_kw)
@@ -229,7 +268,7 @@ def get_config_form():
                     if c.key != ConfigEnum.decoy_domain:
                         validators.append(wtf.validators.NoneOf([d.domain.lower() for d in Domain.query.all()], _("config.Domain already used")))
                         validators.append(wtf.validators.NoneOf(
-                            [cc.value.lower() for cc in StrConfig.query.filter(StrConfig.child_id == Child.current.id).all() if cc.key != c.key and "fakedomain" in cc.key and cc.key != ConfigEnum.decoy_domain], _("config.Domain already used")))
+                            [cc.value.lower() for cc in StrConfig.query.filter(StrConfig.child_id == Child.current().id).all() if cc.key != c.key and "fakedomain" in cc.key and cc.key != ConfigEnum.decoy_domain], _("config.Domain already used")))
 
                     render_kw['required'] = ""
                     if len(c.value) < 3: